sunholo 0.143.3__tar.gz → 0.143.9__tar.gz

{sunholo-0.143.3/src/sunholo.egg-info → sunholo-0.143.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.3
+Version: 0.143.9
 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

{sunholo-0.143.3 → sunholo-0.143.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sunholo"
-version = "0.143.3"
+version = "0.143.9"
 description = "AI DevOps - a package to help deploy GenAI to the Cloud."
 readme = "README.md"
 requires-python = ">=3.11"

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/__init__.py

@@ -15,7 +15,10 @@ from . import invoke
 from . import langfuse
 from . import llamaindex
 from . import lookup
-from . import mcp
+try:
+    from . import mcp
+except ImportError:
+    mcp = None
 from . import ollama
 from . import pubsub
 from . import qna

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/agents/flask/vac_routes.py

@@ -38,12 +38,14 @@ except ImportError:
 
 try:
     from ...mcp.vac_mcp_server import VACMCPServer
-    from mcp.server.models import InitializationOptions
-    from mcp import JSONRPCMessage, ErrorData, INTERNAL_ERROR
+    from mcp.server import Server
+    from mcp.types import JSONRPCMessage, ErrorData, INTERNAL_ERROR
 except ImportError:
     VACMCPServer = None
-    InitializationOptions = None
+    Server = None
     JSONRPCMessage = None
+    ErrorData = None
+    INTERNAL_ERROR = None
 
 try:
     from ...a2a.vac_a2a_agent import VACA2AAgent
@@ -1024,75 +1026,64 @@ if __name__ == "__main__":
                 
                 # 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
+                    # Handle JSON-RPC requests directly
+                    if not isinstance(data, dict) or "method" not in data:
+                        raise ValueError("Invalid JSON-RPC request")
                     
-                    # 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())
+                    method = data["method"]
+                    params = data.get("params", {})
+                    request_id = data.get("id")
                     
                     try:
-                        # Process the request through the server
-                        await server.run(
-                            read_messages(),
-                            write_queue,
-                            InitializationOptions() if InitializationOptions else None
-                        )
+                        # Handle different MCP methods
+                        if method == "tools/list":
+                            # Get the server and call list_tools handler
+                            server = self.vac_mcp_server.get_server()
+                            tools = await server._request_handlers["tools/list"]()
+                            
+                            return {
+                                "jsonrpc": "2.0",
+                                "result": {"tools": [tool.model_dump() for tool in tools]},
+                                "id": request_id
+                            }
+                            
+                        elif method == "tools/call":
+                            # Handle tool calls
+                            tool_name = params.get("name")
+                            arguments = params.get("arguments", {})
+                            
+                            if not tool_name:
+                                raise ValueError("Missing tool name")
+                            
+                            server = self.vac_mcp_server.get_server()
+                            result = await server._request_handlers["tools/call"](tool_name, arguments)
+                            
+                            return {
+                                "jsonrpc": "2.0", 
+                                "result": {"content": [item.model_dump() for item in result]},
+                                "id": request_id
+                            }
+                            
+                        else:
+                            raise ValueError(f"Unknown method: {method}")
+                            
                     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
+                        log.error(f"Error handling MCP method {method}: {e}")
+                        return {
+                            "jsonrpc": "2.0",
+                            "error": {
+                                "code": -32603,
+                                "message": str(e)
+                            },
+                            "id": request_id
+                        }
                 
                 # 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
+                    response_data = loop.run_until_complete(process_request())
+                    return jsonify(response_data)
 
                 except Exception as e:
                     log.error(f"MCP server error: {str(e)}")

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/mcp/__init__.py

@@ -14,7 +14,16 @@
 
 """MCP (Model Context Protocol) integration for Sunholo."""
 
-from .mcp_manager import MCPClientManager
-from .vac_mcp_server import VACMCPServer
+try:
+    from .mcp_manager import MCPClientManager
+except ImportError as e:
+    print(f"Warning: MCPClientManager not available - {e}")
+    MCPClientManager = None
+
+try:
+    from .vac_mcp_server import VACMCPServer
+except ImportError as e:
+    print(f"Warning: VACMCPServer not available - {e}")
+    VACMCPServer = None
 
 __all__ = ['MCPClientManager', 'VACMCPServer']

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/mcp/mcp_manager.py

@@ -4,11 +4,34 @@ This shows how to integrate MCP servers with your Flask/VACRoutes application.
 """
 
 from typing import Dict, Any, List, Optional
+import asyncio
 
-# Official MCP imports
-from mcp import StdioServerParameters, ClientSession
-from mcp.client.stdio import stdio_client
-from mcp.types import Tool, Resource, TextContent, CallToolResult
+# MCP SDK imports - try different import paths
+try:
+    from mcp.client.stdio import StdioClientTransport
+    from mcp.client.session import ClientSession
+except ImportError:
+    try:
+        # Alternative import paths
+        from mcp.client import StdioClientTransport, ClientSession
+    except ImportError:
+        try:
+            # Another alternative
+            from mcp import StdioClientTransport, ClientSession
+        except ImportError:
+            StdioClientTransport = None
+            ClientSession = None
+
+try:
+    from mcp.types import Tool, Resource, TextContent, CallToolResult
+except ImportError:
+    try:
+        from mcp import Tool, Resource, TextContent, CallToolResult
+    except ImportError:
+        Tool = None
+        Resource = None
+        TextContent = None
+        CallToolResult = None
 
 
 class MCPClientManager:
@@ -23,41 +46,42 @@ class MCPClientManager:
         if server_name in self.sessions:
             return self.sessions[server_name]
         
-        # Create server parameters
-        server_params = StdioServerParameters(
+        if not StdioClientTransport or not ClientSession:
+            raise ImportError("MCP client dependencies not available")
+        
+        # Create transport and session
+        transport = StdioClientTransport(
             command=command,
             args=args or []
         )
+        session = ClientSession(transport)
+        await session.initialize()
         
-        # Connect to the server
-        async with stdio_client(server_params) as (read, write):
-            # Create and initialize client session directly
-            session = ClientSession(read, write)
-            await session.initialize()
-            self.sessions[server_name] = session
-            self.server_configs[server_name] = {
-                "command": command,
-                "args": args
-            }
-            return session
+        self.sessions[server_name] = session
+        self.server_configs[server_name] = {
+            "command": command,
+            "args": args
+        }
+        return session
     
     async def list_tools(self, server_name: Optional[str] = None) -> List[Tool]:
         """List available tools from one or all connected servers."""
         if server_name:
             session = self.sessions.get(server_name)
             if session:
-                return await session.list_tools()
+                result = await session.list_tools()
+                return result.tools
             return []
         
         # List from all servers
         all_tools = []
         for name, session in self.sessions.items():
-            tools = await session.list_tools()
+            result = await session.list_tools()
             # Add server name to tool metadata
-            for tool in tools:
+            for tool in result.tools:
                 tool.metadata = tool.metadata or {}
                 tool.metadata["server"] = name
-            all_tools.extend(tools)
+            all_tools.extend(result.tools)
         return all_tools
     
     async def call_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> CallToolResult:
@@ -67,7 +91,13 @@ class MCPClientManager:
             raise ValueError(f"Not connected to server: {server_name}")
         
         # Call the tool
-        result = await session.call_tool(tool_name, arguments)
+        try:
+            from mcp.types import CallToolRequest
+            request = CallToolRequest(name=tool_name, arguments=arguments)
+            result = await session.call_tool(request)
+        except ImportError:
+            # Try direct call if Request types not available
+            result = await session.call_tool(tool_name, arguments)
         return result
     
     async def list_resources(self, server_name: Optional[str] = None) -> List[Resource]:
@@ -75,17 +105,18 @@ class MCPClientManager:
         if server_name:
             session = self.sessions.get(server_name)
             if session:
-                return await session.list_resources()
+                result = await session.list_resources()
+                return result.resources
             return []
         
         # List from all servers
         all_resources = []
         for name, session in self.sessions.items():
-            resources = await session.list_resources()
-            for resource in resources:
+            result = await session.list_resources()
+            for resource in result.resources:
                 resource.metadata = resource.metadata or {}
                 resource.metadata["server"] = name
-            all_resources.extend(resources)
+            all_resources.extend(result.resources)
         return all_resources
     
     async def read_resource(self, server_name: str, uri: str) -> List[TextContent]:
@@ -94,5 +125,12 @@ class MCPClientManager:
         if not session:
             raise ValueError(f"Not connected to server: {server_name}")
         
-        result = await session.read_resource(uri)
-        return result.contents
+        try:
+            from mcp.types import ReadResourceRequest
+            request = ReadResourceRequest(uri=uri)
+            result = await session.read_resource(request)
+        except ImportError:
+            # Try direct call if Request types not available
+            result = await session.read_resource(uri)
+        
+        return result.contents if hasattr(result, 'contents') else result

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/mcp/vac_mcp_server.py

@@ -22,13 +22,8 @@ import json
 import asyncio
 from functools import partial
 
-try:
-    from mcp.server import Server
-    from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
-except ImportError:
-    Server = None
-    Tool = None
-    TextContent = None
+from mcp.server import Server
+from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
 
 from ..custom_logging import log
 from ..streaming import start_streaming_chat_async
@@ -45,8 +40,7 @@ class VACMCPServer:
             stream_interpreter: The streaming interpreter function
             vac_interpreter: The static VAC interpreter function (optional)
         """
-        if Server is None:
-            raise ImportError("MCP server requires `pip install sunholo[anthropic]`")
+        # MCP server is always available with current SDK
         
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter
@@ -172,18 +166,31 @@ class VACMCPServer:
             # Collect streaming responses
             full_response = ""
             
-            async for chunk in start_streaming_chat_async(
-                question=user_input,
-                vector_name=vector_name,
-                qna_func_async=self.stream_interpreter,
-                chat_history=chat_history,
-                wait_time=stream_wait_time,
-                timeout=stream_timeout
-            ):
-                if isinstance(chunk, dict) and 'answer' in chunk:
-                    full_response = chunk['answer']
-                elif isinstance(chunk, str):
-                    full_response += chunk
+            # Check if stream_interpreter is async
+            if asyncio.iscoroutinefunction(self.stream_interpreter):
+                async for chunk in start_streaming_chat_async(
+                    question=user_input,
+                    vector_name=vector_name,
+                    qna_func_async=self.stream_interpreter,
+                    chat_history=chat_history,
+                    wait_time=stream_wait_time,
+                    timeout=stream_timeout
+                ):
+                    if isinstance(chunk, dict) and 'answer' in chunk:
+                        full_response = chunk['answer']
+                    elif isinstance(chunk, str):
+                        full_response += chunk
+            else:
+                # Fall back to sync version for non-async interpreters
+                result = self.stream_interpreter(
+                    question=user_input,
+                    vector_name=vector_name,
+                    chat_history=chat_history
+                )
+                if isinstance(result, dict):
+                    full_response = result.get("answer", str(result))
+                else:
+                    full_response = str(result)
             
             return [
                 TextContent(

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo/streaming/streaming.py

@@ -167,16 +167,16 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
     content_buffer = ContentBuffer()
     chat_callback_handler = BufferStreamingStdOutCallbackHandlerAsync(content_buffer=content_buffer, tokens=".!?\n")
 
-    result_queue = Queue()
-    exception_queue = Queue()
-    stop_event = Event()
+    result_queue = asyncio.Queue()
+    exception_queue = asyncio.Queue()
+    stop_event = asyncio.Event()
 
     async def start_chat():
         try:
             final_result = await qna_func_async(question, vector_name, chat_history, callback=chat_callback_handler, **kwargs)
-            result_queue.put(final_result)
+            await result_queue.put(final_result)
         except Exception as e:
-            exception_queue.put(e)
+            await exception_queue.put(e)
 
     # Run start_chat asynchronously
     chat_task = asyncio.create_task(start_chat())
@@ -222,10 +222,10 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
         final_yield = ""
     else:
         log.info("Sending final full message plus sources...")
-        if not result_queue.empty():
-            final_result = result_queue.get()
+        try:
+            final_result = result_queue.get_nowait()
             final_yield = parse_output(final_result)
-        else:
+        except asyncio.QueueEmpty:
             final_yield = ""
 
     # Match the non-async behavior - yield the parsed output directly, not as JSON

{sunholo-0.143.3 → sunholo-0.143.9/src/sunholo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.3
+Version: 0.143.9
 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

{sunholo-0.143.3 → sunholo-0.143.9}/src/sunholo.egg-info/SOURCES.txt

@@ -190,5 +190,4 @@ tests/test_async_genai2.py
 tests/test_chat_history.py
 tests/test_config.py
 tests/test_genai2.py
-tests/test_unstructured.py
-tests/test_vac_routes_mcp.py
+tests/test_unstructured.py