sunholo 0.141.1__tar.gz → 0.143.1__tar.gz

{sunholo-0.141.1/src/sunholo.egg-info → sunholo-0.143.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.141.1
+Version: 0.143.1
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
@@ -19,10 +19,11 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aiohttp
+Requires-Dist: flask>=3.1.0
 Requires-Dist: google-auth
-Requires-Dist: ollama>=0.4.7
-Requires-Dist: pillow>=11.0.0
+Requires-Dist: mcp>=1.1.1
 Requires-Dist: pydantic
+Requires-Dist: pytest-asyncio>=1.0.0
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
 Requires-Dist: tenacity
@@ -69,7 +70,7 @@ Requires-Dist: langchain-anthropic>=0.1.23; extra == "all"
 Requires-Dist: langchain-google-vertexai; extra == "all"
 Requires-Dist: langchain-unstructured; extra == "all"
 Requires-Dist: langfuse; extra == "all"
-Requires-Dist: mcp; extra == "all"
+Requires-Dist: mcp>=1.1.1; extra == "all"
 Requires-Dist: numpy; extra == "all"
 Requires-Dist: opencv-python; extra == "all"
 Requires-Dist: pg8000; extra == "all"
@@ -155,7 +156,7 @@ Requires-Dist: langchain-openai>=0.3.2; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic>=0.1.23; extra == "anthropic"
-Requires-Dist: mcp; extra == "anthropic"
+Requires-Dist: mcp>=1.1.1; extra == "anthropic"
 Provides-Extra: tools
 Requires-Dist: openapi-spec-validator; extra == "tools"
 Requires-Dist: playwright; extra == "tools"

{sunholo-0.141.1 → sunholo-0.143.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sunholo"
-version = "0.141.1"
+version = "0.143.1"
 description = "AI DevOps - a package to help deploy GenAI to the Cloud."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,10 +26,11 @@ classifiers = [
 
 dependencies = [
     "aiohttp",
+    "flask>=3.1.0",
     "google-auth",
-    "ollama>=0.4.7",
-    "pillow>=11.0.0",
+    "mcp>=1.1.1",
     "pydantic",
+    "pytest-asyncio>=1.0.0",
     "requests",
     "ruamel.yaml",
     "tenacity",
@@ -100,7 +101,7 @@ all = [
     "langchain-google-vertexai",
     "langchain-unstructured",
     "langfuse",
-    "mcp",
+    "mcp>=1.1.1",
     "numpy",
     "opencv-python",
     "pg8000",
@@ -195,7 +196,7 @@ openai = [
 ]
 anthropic = [
     "langchain-anthropic>=0.1.23",
-    "mcp"
+    "mcp>=1.1.1"
 ]
 tools = [
     "openapi-spec-validator",

{sunholo-0.141.1 → sunholo-0.143.1}/src/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,21 @@ 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
+
+
 # Cache dictionary to store validated API keys
 api_key_cache = {}
 cache_duration = timedelta(minutes=5)  # Cache duration
@@ -61,11 +78,30 @@ 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):
         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
+            )
+
         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 +165,18 @@ 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)
     
         self.register_additional_routes()
 
@@ -803,3 +851,254 @@ 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"]
+            })

{sunholo-0.141.1 → sunholo-0.143.1}/src/sunholo/invoke/async_class.py

@@ -8,12 +8,39 @@ from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponen
 log = setup_logging("sunholo_AsyncTaskRunner")
 
 class AsyncTaskRunner:
-    def __init__(self, retry_enabled:bool=False, retry_kwargs:dict=None, timeout:int=120, max_concurrency:int=20):
+    def __init__(self, 
+                 retry_enabled: bool = False, 
+                 retry_kwargs: dict = None, 
+                 timeout: int = 120, 
+                 max_concurrency: int = 20,
+                 heartbeat_extends_timeout: bool = False,
+                 hard_timeout: int = None):
+        """
+        Initialize AsyncTaskRunner with configurable timeout behavior.
+        
+        Args:
+            retry_enabled: Whether to enable retries
+            retry_kwargs: Retry configuration
+            timeout: Base timeout for tasks (seconds)
+            max_concurrency: Maximum concurrent tasks
+            heartbeat_extends_timeout: If True, heartbeats reset the timeout timer
+            hard_timeout: Maximum absolute timeout regardless of heartbeats (seconds).
+                         If None, defaults to timeout * 5 when heartbeat_extends_timeout=True
+        """
         self.tasks = []
         self.retry_enabled = retry_enabled
         self.retry_kwargs = retry_kwargs or {}
         self.timeout = timeout
         self.semaphore = asyncio.Semaphore(max_concurrency)
+        self.heartbeat_extends_timeout = heartbeat_extends_timeout
+        
+        # Set hard timeout
+        if hard_timeout is not None:
+            self.hard_timeout = hard_timeout
+        elif heartbeat_extends_timeout:
+            self.hard_timeout = timeout * 5  # Default to 5x base timeout
+        else:
+            self.hard_timeout = timeout  # Same as regular timeout
 
     def add_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any):
         """
@@ -39,9 +66,11 @@ class AsyncTaskRunner:
         for name, func, args, kwargs in self.tasks:
             log.info(f"Executing task: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             completion_event = asyncio.Event()
-            task_coro = self._run_with_retries_and_timeout(name, func, args, kwargs, queue, completion_event)            
+            last_heartbeat = {'time': time.time()}  # Shared mutable object for heartbeat tracking
+            
+            task_coro = self._run_with_retries_and_timeout(name, func, args, kwargs, queue, completion_event, last_heartbeat)            
             task = asyncio.create_task(task_coro)
-            heartbeat_coro = self._send_heartbeat(name, completion_event, queue)
+            heartbeat_coro = self._send_heartbeat(name, completion_event, queue, last_heartbeat)
             heartbeat_task = asyncio.create_task(heartbeat_coro)
             task_infos.append({
                 'name': name,
@@ -93,9 +122,12 @@ class AsyncTaskRunner:
                                             args: tuple,
                                             kwargs: dict,
                                             queue: asyncio.Queue, 
-                                            completion_event: asyncio.Event) -> None:
+                                            completion_event: asyncio.Event,
+                                            last_heartbeat: dict) -> None:
         try:
             log.info(f"run_with_retries_and_timeout: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
+            log.info(f"Timeout mode: heartbeat_extends_timeout={self.heartbeat_extends_timeout}, timeout={self.timeout}s, hard_timeout={self.hard_timeout}s")
+            
             if self.retry_enabled:
                 retry_kwargs = {
                     'wait': wait_random_exponential(multiplier=1, max=60),
@@ -106,13 +138,13 @@ class AsyncTaskRunner:
                 async for attempt in AsyncRetrying(**retry_kwargs):
                     with attempt:
                         log.info(f"Starting task '{name}' with retry")
-                        result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+                        result = await self._execute_task_with_timeout(func, name, last_heartbeat, *args, **kwargs)
                         await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                         log.info(f"Sent 'task_complete' message for task '{name}'")
                         return
             else:
                 log.info(f"Starting task '{name}' with no retry")
-                result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+                result = await self._execute_task_with_timeout(func, name, last_heartbeat, *args, **kwargs)
                 await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                 log.info(f"Sent 'task_complete' message for task '{name}'")
         except asyncio.TimeoutError:
@@ -125,6 +157,55 @@ class AsyncTaskRunner:
             log.info(f"Task '{name}' completed.")
             completion_event.set()
 
+    async def _execute_task_with_timeout(self, func: Callable[..., Any], name: str, last_heartbeat: dict, *args: Any, **kwargs: Any) -> Any:
+        """
+        Execute task with either fixed timeout or heartbeat-extendable timeout.
+        """
+        if not self.heartbeat_extends_timeout:
+            # Original behavior - fixed timeout
+            return await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
+        else:
+            # New behavior - heartbeat extends timeout
+            return await self._execute_task_with_heartbeat_timeout(func, name, last_heartbeat, *args, **kwargs)
+
+    async def _execute_task_with_heartbeat_timeout(self, func: Callable[..., Any], name: str, last_heartbeat: dict, *args: Any, **kwargs: Any) -> Any:
+        """
+        Execute task with heartbeat-extendable timeout and hard timeout limit.
+        """
+        start_time = time.time()
+        task = asyncio.create_task(self._execute_task(func, *args, **kwargs))
+        
+        while not task.done():
+            current_time = time.time()
+            
+            # Check hard timeout first (absolute limit)
+            if current_time - start_time > self.hard_timeout:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+                raise asyncio.TimeoutError(f"Hard timeout exceeded ({self.hard_timeout}s)")
+            
+            # Check soft timeout (extends with heartbeats)
+            time_since_heartbeat = current_time - last_heartbeat['time']
+            if time_since_heartbeat > self.timeout:
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+                raise asyncio.TimeoutError(f"Timeout exceeded - no heartbeat for {self.timeout}s")
+            
+            # Wait a bit before checking again
+            try:
+                await asyncio.wait_for(asyncio.shield(task), timeout=1.0)
+                break  # Task completed
+            except asyncio.TimeoutError:
+                continue  # Check timeouts again
+        
+        return await task
+
     async def _execute_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         """
         Executes the given task function and returns its result.
@@ -143,14 +224,16 @@ class AsyncTaskRunner:
             else:
                 return await asyncio.to_thread(func, *args, **kwargs)
 
-    async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, interval: int = 2):
+    async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, last_heartbeat: dict, interval: int = 2):
         """
         Sends periodic heartbeat updates to indicate the task is still in progress.
+        Updates last_heartbeat time if heartbeat_extends_timeout is enabled.
 
         Args:
             func_name (str): The name of the task function.
             completion_event (asyncio.Event): Event to signal when the task is completed.
             queue (asyncio.Queue): The queue to send heartbeat messages to.
+            last_heartbeat (dict): Mutable dict containing the last heartbeat time.
             interval (int): How frequently to send heartbeat messages (in seconds).
         """
         start_time = time.time()
@@ -158,7 +241,14 @@ class AsyncTaskRunner:
         try:
             while not completion_event.is_set():
                 await asyncio.sleep(interval)
-                elapsed_time = int(time.time() - start_time)
+                current_time = time.time()
+                elapsed_time = int(current_time - start_time)
+                
+                # Update last heartbeat time if heartbeat extends timeout
+                if self.heartbeat_extends_timeout:
+                    last_heartbeat['time'] = current_time
+                    log.debug(f"Updated heartbeat time for task '{func_name}' at {current_time}")
+                
                 heartbeat_message = {
                     'type': 'heartbeat',
                     'name': func_name,

sunholo-0.143.1/src/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']