sunholo 0.142.0__py3-none-any.whl → 0.143.3__py3-none-any.whl

sunholo/agents/flask/vac_routes.py

@@ -6,6 +6,8 @@ import random
 from functools import partial
 import inspect
 import asyncio
+from typing import Dict, List, Optional, Callable, Any
+
 
 from ..chat_history import extract_chat_history_with_cache, extract_chat_history_async_cached
 from ...qna.parsers import parse_output
@@ -29,6 +31,26 @@ try:
 except ImportError:
     PubSubManager = None
 
+try:
+    from ...mcp.mcp_manager import MCPClientManager
+except ImportError:
+    MCPClientManager = None
+
+try:
+    from ...mcp.vac_mcp_server import VACMCPServer
+    from mcp.server.models import InitializationOptions
+    from mcp import JSONRPCMessage, ErrorData, INTERNAL_ERROR
+except ImportError:
+    VACMCPServer = None
+    InitializationOptions = None
+    JSONRPCMessage = None
+
+try:
+    from ...a2a.vac_a2a_agent import VACA2AAgent
+except (ImportError, SyntaxError):
+    VACA2AAgent = None
+
+
 # Cache dictionary to store validated API keys
 api_key_cache = {}
 cache_duration = timedelta(minutes=5)  # Cache duration
@@ -61,11 +83,41 @@ if __name__ == "__main__":
                  stream_interpreter: callable, 
                  vac_interpreter:callable=None, 
                  additional_routes:dict=None, 
+                 mcp_servers: List[Dict[str, Any]] = None,
                  async_stream:bool=False,
-                 add_langfuse_eval:bool=True):
+                 add_langfuse_eval:bool=True,
+                 enable_mcp_server:bool=False,
+                 enable_a2a_agent:bool=False,
+                 a2a_vac_names: List[str] = None):
         self.app = app
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter or partial(self.vac_interpreter_default)
+
+        # MCP client initialization
+        self.mcp_servers = mcp_servers or []
+        self.mcp_client_manager = MCPClientManager()    
+        # Initialize MCP connections
+        if self.mcp_servers and self.mcp_client_manager:
+            asyncio.create_task(self._initialize_mcp_servers())
+
+        # MCP server initialization
+        self.enable_mcp_server = enable_mcp_server
+        self.vac_mcp_server = None
+        if self.enable_mcp_server and VACMCPServer:
+            self.vac_mcp_server = VACMCPServer(
+                stream_interpreter=self.stream_interpreter,
+                vac_interpreter=self.vac_interpreter
+            )
+
+        # A2A agent initialization  
+        self.enable_a2a_agent = enable_a2a_agent
+        self.vac_a2a_agent = None
+        self.a2a_vac_names = a2a_vac_names
+        if self.enable_a2a_agent and VACA2AAgent:
+            # Extract base URL from request context during route handling
+            # For now, initialize with placeholder - will be updated in route handlers
+            self.vac_a2a_agent = None  # Initialized lazily in route handlers
+
         self.additional_routes = additional_routes if additional_routes is not None else []
         self.async_stream = async_stream
         self.add_langfuse_eval = add_langfuse_eval
@@ -129,6 +181,27 @@ if __name__ == "__main__":
         # OpenAI compatible endpoint
         self.app.route('/openai/v1/chat/completions', methods=['POST'])(self.handle_openai_compatible_endpoint)
         self.app.route('/openai/v1/chat/completions/<vector_name>', methods=['POST'])(self.handle_openai_compatible_endpoint)
+
+        # MCP client routes
+        if self.mcp_servers:
+            self.app.route('/mcp/tools', methods=['GET'])(self.handle_mcp_list_tools)
+            self.app.route('/mcp/tools/<server_name>', methods=['GET'])(self.handle_mcp_list_tools)
+            self.app.route('/mcp/call', methods=['POST'])(self.handle_mcp_call_tool)
+            self.app.route('/mcp/resources', methods=['GET'])(self.handle_mcp_list_resources)
+            self.app.route('/mcp/resources/read', methods=['POST'])(self.handle_mcp_read_resource)
+        
+        # MCP server endpoint
+        if self.enable_mcp_server and self.vac_mcp_server:
+            self.app.route('/mcp', methods=['POST', 'GET'])(self.handle_mcp_server)
+        
+        # A2A agent endpoints
+        if self.enable_a2a_agent:
+            self.app.route('/.well-known/agent.json', methods=['GET'])(self.handle_a2a_agent_card)
+            self.app.route('/a2a/tasks/send', methods=['POST'])(self.handle_a2a_task_send)
+            self.app.route('/a2a/tasks/sendSubscribe', methods=['POST'])(self.handle_a2a_task_send_subscribe)
+            self.app.route('/a2a/tasks/get', methods=['POST'])(self.handle_a2a_task_get)
+            self.app.route('/a2a/tasks/cancel', methods=['POST'])(self.handle_a2a_task_cancel)
+            self.app.route('/a2a/tasks/pushNotification/set', methods=['POST'])(self.handle_a2a_push_notification)
     
         self.register_additional_routes()
 
@@ -803,3 +876,474 @@ if __name__ == "__main__":
         except Exception as e:
             raise Exception(f'File upload failed: {str(e)}')
 
+    async def _initialize_mcp_servers(self):
+        """Initialize connections to configured MCP servers."""
+        for server_config in self.mcp_servers:
+            try:
+                await self.mcp_client_manager.connect_to_server(
+                    server_name=server_config["name"],
+                    command=server_config["command"],
+                    args=server_config.get("args", [])
+                )
+                log.info(f"Connected to MCP server: {server_config['name']}")
+            except Exception as e:
+                log.error(f"Failed to connect to MCP server {server_config['name']}: {e}")
+
+    
+    def handle_mcp_list_tools(self, server_name: Optional[str] = None):
+        """List available MCP tools."""
+        async def get_tools():
+            tools = await self.mcp_client_manager.list_tools(server_name)
+            return [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "inputSchema": tool.inputSchema,
+                    "server": tool.metadata.get("server") if tool.metadata else server_name
+                }
+                for tool in tools
+            ]
+        
+        # Run async in sync context
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            tools = loop.run_until_complete(get_tools())
+            return jsonify({"tools": tools})
+        finally:
+            loop.close()
+    
+    def handle_mcp_call_tool(self):
+        """Call an MCP tool."""
+        data = request.get_json()
+        server_name = data.get("server")
+        tool_name = data.get("tool")
+        arguments = data.get("arguments", {})
+        
+        if not server_name or not tool_name:
+            return jsonify({"error": "Missing 'server' or 'tool' parameter"}), 400
+        
+        async def call_tool():
+            try:
+                result = await self.mcp_client_manager.call_tool(server_name, tool_name, arguments)
+                
+                # Convert result to JSON-serializable format
+                if hasattr(result, 'content'):
+                    # Handle different content types
+                    if hasattr(result.content, 'text'):
+                        return {"result": result.content.text}
+                    elif hasattr(result.content, 'data'):
+                        return {"result": result.content.data}
+                    else:
+                        return {"result": str(result.content)}
+                else:
+                    return {"result": str(result)}
+                    
+            except Exception as e:
+                return {"error": str(e)}
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(call_tool())
+            if "error" in result:
+                return jsonify(result), 500
+            return jsonify(result)
+        finally:
+            loop.close()
+    
+    def handle_mcp_list_resources(self):
+        """List available MCP resources."""
+        server_name = request.args.get("server")
+        
+        async def get_resources():
+            resources = await self.mcp_client_manager.list_resources(server_name)
+            return [
+                {
+                    "uri": resource.uri,
+                    "name": resource.name,
+                    "description": resource.description,
+                    "mimeType": resource.mimeType,
+                    "server": resource.metadata.get("server") if resource.metadata else server_name
+                }
+                for resource in resources
+            ]
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            resources = loop.run_until_complete(get_resources())
+            return jsonify({"resources": resources})
+        finally:
+            loop.close()
+    
+    def handle_mcp_read_resource(self):
+        """Read an MCP resource."""
+        data = request.get_json()
+        server_name = data.get("server")
+        uri = data.get("uri")
+        
+        if not server_name or not uri:
+            return jsonify({"error": "Missing 'server' or 'uri' parameter"}), 400
+        
+        async def read_resource():
+            try:
+                contents = await self.mcp_client_manager.read_resource(server_name, uri)
+                return {
+                    "contents": [
+                        {"text": content.text} if hasattr(content, 'text') else {"data": str(content)}
+                        for content in contents
+                    ]
+                }
+            except Exception as e:
+                return {"error": str(e)}
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(read_resource())
+            if "error" in result:
+                return jsonify(result), 500
+            return jsonify(result)
+        finally:
+            loop.close()
+    
+    def handle_mcp_server(self):
+        """Handle MCP server requests using HTTP transport."""
+        if not self.vac_mcp_server:
+            return jsonify({"error": "MCP server not enabled"}), 501
+        
+        import json as json_module
+        
+        # Handle streaming for HTTP transport
+        if request.method == 'POST':
+            try:
+                # Get the JSON-RPC request
+                data = request.get_json()
+                log.info(f"MCP server received: {data}")
+                
+                # Create an async handler for the request
+                async def process_request():
+                    # Create mock read/write streams for the server
+                    from io import StringIO
+                    import asyncio
+                    
+                    # Convert request to proper format
+                    request_str = json_module.dumps(data) + '\n'
+                    
+                    # Create read queue with the request
+                    read_queue = asyncio.Queue()
+                    await read_queue.put(request_str.encode())
+                    await read_queue.put(None)  # EOF signal
+                    
+                    # Create write queue for response
+                    write_queue = asyncio.Queue()
+                    
+                    # Create async iterators
+                    async def read_messages():
+                        while True:
+                            msg = await read_queue.get()
+                            if msg is None:
+                                break
+                            yield msg
+                    
+                    responses = []
+                    async def write_messages():
+                        async for msg in write_queue:
+                            if msg is None:
+                                break
+                            responses.append(msg.decode())
+                    
+                    # Run the server with these streams
+                    server = self.vac_mcp_server.get_server()
+                    
+                    # Start write handler
+                    write_task = asyncio.create_task(write_messages())
+                    
+                    try:
+                        # Process the request through the server
+                        await server.run(
+                            read_messages(),
+                            write_queue,
+                            InitializationOptions() if InitializationOptions else None
+                        )
+                    except Exception as e:
+                        log.error(f"Error processing MCP request: {e}")
+                        await write_queue.put(None)
+                        await write_task
+                        raise
+                    
+                    # Signal end and wait for write task
+                    await write_queue.put(None)
+                    await write_task
+                    
+                    # Return collected responses
+                    return responses
+                
+                # Run the async handler
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    responses = loop.run_until_complete(process_request())
+                    
+                    # Parse and return the response
+                    if responses:
+                        # The response should be a single JSON-RPC response
+                        response_data = json_module.loads(responses[0])
+                        return jsonify(response_data)
+                    else:
+                        return jsonify({"error": "No response from MCP server"}), 500
+
+                except Exception as e:
+                    log.error(f"MCP server error: {str(e)}")
+                    return jsonify({
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32603,
+                            "message": f"Internal error: {str(e)}"
+                        },
+                        "id": data.get("id") if isinstance(data, dict) else None
+                    }), 500
+                finally:
+                    loop.close()
+                        
+            except Exception as e:
+                log.error(f"MCP server error: {str(e)}")
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32603,
+                        "message": f"Internal error: {str(e)}"
+                    },
+                    "id": data.get("id") if isinstance(data, dict) else None
+                }), 500
+                    
+        else:
+            # GET request - return server information
+            return jsonify({
+                "name": "sunholo-vac-server",
+                "version": "1.0.0",
+                "transport": "http",
+                "endpoint": "/mcp",
+                "tools": ["vac_stream", "vac_query"] if self.vac_interpreter else ["vac_stream"]
+            })
+    
+    def _get_or_create_a2a_agent(self):
+        """Get or create the A2A agent instance with current request context."""
+        if not self.enable_a2a_agent or not VACA2AAgent:
+            return None
+        
+        if self.vac_a2a_agent is None:
+            # Extract base URL from current request
+            base_url = request.url_root.rstrip('/')
+            
+            self.vac_a2a_agent = VACA2AAgent(
+                base_url=base_url,
+                stream_interpreter=self.stream_interpreter,
+                vac_interpreter=self.vac_interpreter,
+                vac_names=self.a2a_vac_names
+            )
+        
+        return self.vac_a2a_agent
+    
+    def handle_a2a_agent_card(self):
+        """Handle A2A agent card discovery request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        return jsonify(agent.get_agent_card())
+    
+    def handle_a2a_task_send(self):
+        """Handle A2A task send request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_send(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task send error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_send_subscribe(self):
+        """Handle A2A task send with subscription (SSE)."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                def error_generator():
+                    yield "data: {\"error\": \"Parse error: Invalid JSON\"}\n\n"
+                
+                return Response(error_generator(), content_type='text/event-stream')
+            
+            # Create async generator for SSE
+            async def sse_generator():
+                async for chunk in agent.handle_task_send_subscribe(data):
+                    yield chunk
+            
+            def sync_generator():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    async_gen = sse_generator()
+                    while True:
+                        try:
+                            chunk = loop.run_until_complete(async_gen.__anext__())
+                            yield chunk
+                        except StopAsyncIteration:
+                            break
+                finally:
+                    loop.close()
+            
+            return Response(sync_generator(), content_type='text/event-stream')
+            
+        except Exception as e:
+            log.error(f"A2A task send subscribe error: {e}")
+            def error_generator(err):
+                yield f"data: {{\"error\": \"Internal error: {str(err)}\"}}\n\n"
+            
+            return Response(error_generator(e), content_type='text/event-stream')
+    
+    def handle_a2a_task_get(self):
+        """Handle A2A task get request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_get(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task get error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_cancel(self):
+        """Handle A2A task cancel request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_cancel(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task cancel error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_push_notification(self):
+        """Handle A2A push notification settings."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_push_notification_set(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A push notification error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500

sunholo/mcp/__init__.py

@@ -0,0 +1,20 @@
+#   Copyright [2024] [Holosun ApS]
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+"""MCP (Model Context Protocol) integration for Sunholo."""
+
+from .mcp_manager import MCPClientManager
+from .vac_mcp_server import VACMCPServer
+
+__all__ = ['MCPClientManager', 'VACMCPServer']