sunholo 0.143.7__tar.gz → 0.143.10__tar.gz

{sunholo-0.143.7/src/sunholo.egg-info → sunholo-0.143.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.7
+Version: 0.143.10
 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.7 → sunholo-0.143.10}/pyproject.toml

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

{sunholo-0.143.7 → sunholo-0.143.10}/src/sunholo/agents/flask/vac_routes.py

@@ -1026,58 +1026,57 @@ 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
-                        # Use the server's run method with HTTP transport
-                        await server.run()
+                        # 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()

{sunholo-0.143.7 → sunholo-0.143.10}/src/sunholo/mcp/vac_mcp_server.py

@@ -166,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.7 → sunholo-0.143.10}/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.7 → sunholo-0.143.10/src/sunholo.egg-info}/PKG-INFO

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