sunholo 0.143.16__py3-none-any.whl → 0.144.1__py3-none-any.whl

sunholo/mcp/vac_mcp_server.py

@@ -13,254 +13,11 @@
 #   limitations under the License.
 
 """
-MCP Server wrapper for VAC functionality.
+MCP Server wrapper for VAC functionality using FastMCP.
 This module exposes VAC streaming capabilities as MCP tools.
 """
 
-from typing import Any, Sequence, Dict, List, Optional, Callable
-import json
-import asyncio
-from functools import partial
+# Import the FastMCP implementation
+from .vac_mcp_server_fastmcp import VACMCPServer
 
-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
-
-
-class VACMCPServer:
-    """MCP Server that exposes VAC functionality as tools."""
-    
-    def __init__(self, stream_interpreter: Callable, vac_interpreter: Callable = None):
-        """
-        Initialize the VAC MCP Server.
-        
-        Args:
-            stream_interpreter: The streaming interpreter function
-            vac_interpreter: The static VAC interpreter function (optional)
-        """
-        # MCP server is always available with current SDK
-        
-        self.stream_interpreter = stream_interpreter
-        self.vac_interpreter = vac_interpreter
-        self.server = Server("sunholo-vac-server")
-        
-        # Set up handlers
-        self._setup_handlers()
-    
-    def _setup_handlers(self):
-        """Set up MCP protocol handlers."""
-        
-        @self.server.list_tools()
-        async def list_tools() -> List[Tool]:
-            """List available VAC tools."""
-            tools = [
-                Tool(
-                    name="vac_stream",
-                    description="Stream responses from a Sunholo VAC (Virtual Agent Computer)",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "vector_name": {
-                                "type": "string",
-                                "description": "Name of the VAC to interact with"
-                            },
-                            "user_input": {
-                                "type": "string", 
-                                "description": "The user's question or input"
-                            },
-                            "chat_history": {
-                                "type": "array",
-                                "description": "Previous conversation history",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "human": {"type": "string"},
-                                        "ai": {"type": "string"}
-                                    }
-                                },
-                                "default": []
-                            },
-                            "stream_wait_time": {
-                                "type": "number",
-                                "description": "Time to wait between stream chunks",
-                                "default": 7
-                            },
-                            "stream_timeout": {
-                                "type": "number",
-                                "description": "Maximum time to wait for response",
-                                "default": 120
-                            }
-                        },
-                        "required": ["vector_name", "user_input"]
-                    }
-                )
-            ]
-            
-            # Add static VAC tool if interpreter is provided
-            if self.vac_interpreter:
-                tools.append(
-                    Tool(
-                        name="vac_query",
-                        description="Query a Sunholo VAC (non-streaming)",
-                        inputSchema={
-                            "type": "object",
-                            "properties": {
-                                "vector_name": {
-                                    "type": "string",
-                                    "description": "Name of the VAC to interact with"
-                                },
-                                "user_input": {
-                                    "type": "string",
-                                    "description": "The user's question or input"
-                                },
-                                "chat_history": {
-                                    "type": "array",
-                                    "description": "Previous conversation history",
-                                    "items": {
-                                        "type": "object",
-                                        "properties": {
-                                            "human": {"type": "string"},
-                                            "ai": {"type": "string"}
-                                        }
-                                    },
-                                    "default": []
-                                }
-                            },
-                            "required": ["vector_name", "user_input"]
-                        }
-                    )
-                )
-            
-            return tools
-        
-        @self.server.call_tool()
-        async def call_tool(
-            name: str,
-            arguments: Any
-        ) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
-            """Handle tool calls for VAC interactions."""
-            
-            if name == "vac_stream":
-                return await self._handle_vac_stream(arguments)
-            elif name == "vac_query" and self.vac_interpreter:
-                return await self._handle_vac_query(arguments)
-            else:
-                raise ValueError(f"Unknown tool: {name}")
-    
-    async def _handle_vac_stream(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
-        """Handle streaming VAC requests."""
-        vector_name = arguments.get("vector_name")
-        user_input = arguments.get("user_input")
-        chat_history = arguments.get("chat_history", [])
-        stream_wait_time = arguments.get("stream_wait_time", 7)
-        stream_timeout = arguments.get("stream_timeout", 120)
-        
-        if not vector_name or not user_input:
-            raise ValueError("Missing required arguments: vector_name and user_input")
-        
-        log.info(f"MCP streaming request for VAC '{vector_name}': {user_input}")
-        
-        try:
-            # Collect streaming responses
-            full_response = ""
-            
-            # 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(
-                    type="text",
-                    text=full_response or "No response generated"
-                )
-            ]
-            
-        except Exception as e:
-            log.error(f"Error in MCP VAC stream: {str(e)}")
-            return [
-                TextContent(
-                    type="text",
-                    text=f"Error: {str(e)}"
-                )
-            ]
-    
-    async def _handle_vac_query(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
-        """Handle non-streaming VAC requests."""
-        vector_name = arguments.get("vector_name")
-        user_input = arguments.get("user_input")
-        chat_history = arguments.get("chat_history", [])
-        
-        if not vector_name or not user_input:
-            raise ValueError("Missing required arguments: vector_name and user_input")
-        
-        log.info(f"MCP query request for VAC '{vector_name}': {user_input}")
-        
-        try:
-            # Run in executor if not async
-            if asyncio.iscoroutinefunction(self.vac_interpreter):
-                result = await self.vac_interpreter(
-                    question=user_input,
-                    vector_name=vector_name,
-                    chat_history=chat_history
-                )
-            else:
-                loop = asyncio.get_event_loop()
-                result = await loop.run_in_executor(
-                    None,
-                    partial(
-                        self.vac_interpreter,
-                        question=user_input,
-                        vector_name=vector_name,
-                        chat_history=chat_history
-                    )
-                )
-            
-            # Extract answer from result
-            if isinstance(result, dict):
-                answer = result.get("answer", str(result))
-            else:
-                answer = str(result)
-            
-            return [
-                TextContent(
-                    type="text",
-                    text=answer
-                )
-            ]
-            
-        except Exception as e:
-            log.error(f"Error in MCP VAC query: {str(e)}")
-            return [
-                TextContent(
-                    type="text",
-                    text=f"Error: {str(e)}"
-                )
-            ]
-    
-    def get_server(self) -> Server:
-        """Get the underlying MCP server instance."""
-        return self.server
+__all__ = ['VACMCPServer']

sunholo/mcp/vac_mcp_server_fastmcp.py

@@ -0,0 +1,193 @@
+#   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.
+
+"""
+FastMCP-based MCP Server wrapper for VAC functionality.
+This module exposes VAC streaming capabilities as MCP tools using FastMCP.
+"""
+
+from typing import Any, Callable, Dict, List, Optional
+import asyncio
+from functools import partial
+
+from fastmcp import FastMCP
+
+from ..custom_logging import log
+from ..streaming import start_streaming_chat_async
+
+
+class VACMCPServer:
+    """FastMCP Server that exposes VAC functionality as tools."""
+    
+    def __init__(self, stream_interpreter: Callable, vac_interpreter: Callable = None):
+        """
+        Initialize the VAC MCP Server using FastMCP.
+        
+        Args:
+            stream_interpreter: The streaming interpreter function
+            vac_interpreter: The static VAC interpreter function (optional)
+        """
+        self.stream_interpreter = stream_interpreter
+        self.vac_interpreter = vac_interpreter
+        
+        # Initialize FastMCP server
+        self.server = FastMCP("sunholo-vac-server")
+        
+        # Register tools
+        self._register_tools()
+    
+    def _register_tools(self):
+        """Register VAC tools with FastMCP."""
+        
+        @self.server.tool
+        async def vac_stream(
+            vector_name: str,
+            user_input: str,
+            chat_history: List[Dict[str, str]] = None,
+            stream_wait_time: float = 7,
+            stream_timeout: float = 120
+        ) -> str:
+            """
+            Stream responses from a Sunholo VAC (Virtual Agent Computer).
+            
+            Args:
+                vector_name: Name of the VAC to interact with
+                user_input: The user's question or input
+                chat_history: Previous conversation history
+                stream_wait_time: Time to wait between stream chunks
+                stream_timeout: Maximum time to wait for response
+            
+            Returns:
+                The streamed response from the VAC
+            """
+            if chat_history is None:
+                chat_history = []
+            
+            log.info(f"MCP streaming request for VAC '{vector_name}': {user_input}")
+            
+            try:
+                # Collect streaming responses
+                full_response = ""
+                
+                # 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 full_response or "No response generated"
+                
+            except Exception as e:
+                log.error(f"Error in MCP VAC stream: {str(e)}")
+                return f"Error: {str(e)}"
+        
+        # Register non-streaming tool if interpreter is provided
+        if self.vac_interpreter:
+            @self.server.tool
+            async def vac_query(
+                vector_name: str,
+                user_input: str,
+                chat_history: List[Dict[str, str]] = None
+            ) -> str:
+                """
+                Query a Sunholo VAC (non-streaming).
+                
+                Args:
+                    vector_name: Name of the VAC to interact with
+                    user_input: The user's question or input
+                    chat_history: Previous conversation history
+                
+                Returns:
+                    The response from the VAC
+                """
+                if chat_history is None:
+                    chat_history = []
+                
+                log.info(f"MCP query request for VAC '{vector_name}': {user_input}")
+                
+                try:
+                    # Run in executor if not async
+                    if asyncio.iscoroutinefunction(self.vac_interpreter):
+                        result = await self.vac_interpreter(
+                            question=user_input,
+                            vector_name=vector_name,
+                            chat_history=chat_history
+                        )
+                    else:
+                        loop = asyncio.get_event_loop()
+                        result = await loop.run_in_executor(
+                            None,
+                            partial(
+                                self.vac_interpreter,
+                                question=user_input,
+                                vector_name=vector_name,
+                                chat_history=chat_history
+                            )
+                        )
+                    
+                    # Extract answer from result
+                    if isinstance(result, dict):
+                        answer = result.get("answer", str(result))
+                    else:
+                        answer = str(result)
+                    
+                    return answer
+                    
+                except Exception as e:
+                    log.error(f"Error in MCP VAC query: {str(e)}")
+                    return f"Error: {str(e)}"
+    
+    def get_server(self) -> FastMCP:
+        """Get the underlying FastMCP server instance."""
+        return self.server
+    
+    def run(self, transport: str = "stdio", **kwargs):
+        """
+        Run the MCP server.
+        
+        Args:
+            transport: Transport type ("stdio" or "http")
+            **kwargs: Additional arguments for the transport
+        """
+        self.server.run(transport=transport, **kwargs)
+    
+    async def run_async(self, transport: str = "stdio", **kwargs):
+        """
+        Run the MCP server asynchronously.
+        
+        Args:
+            transport: Transport type ("stdio" or "http")
+            **kwargs: Additional arguments for the transport
+        """
+        await self.server.run_async(transport=transport, **kwargs)

sunholo/streaming/streaming.py

@@ -191,12 +191,22 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
         yield content_to_send
         await content_buffer.async_clear()
 
-    while not chat_callback_handler.stream_finished.is_set() and not stop_event.is_set():
+    # Continue streaming until timeout or stop event
+    start_time = asyncio.get_event_loop().time()
+    while not stop_event.is_set():
         try:
-            await asyncio.wait_for(content_buffer.content_available.wait(), timeout=timeout)
+            # Wait for content with a short timeout to check conditions periodically
+            await asyncio.wait_for(content_buffer.content_available.wait(), timeout=1.0)
         except asyncio.TimeoutError:
-            log.warning(f"Content production has timed out after {timeout} seconds")
-            break
+            # Check if we should continue waiting
+            if chat_callback_handler.stream_finished.is_set() and chat_task.done():
+                # Stream is finished and task is complete, exit loop
+                break
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed > timeout:
+                log.warning(f"Content production has timed out after {timeout} seconds")
+                break
+            continue
 
         content_to_send = await content_buffer.async_read()
         if content_to_send:
@@ -223,13 +233,23 @@ async def start_streaming_chat_async(question, vector_name, qna_func_async, chat
     else:
         log.info("Sending final full message plus sources...")
         try:
-            final_result = result_queue.get_nowait()
+            # Use await with timeout instead of get_nowait to ensure we get the result
+            final_result = await asyncio.wait_for(result_queue.get(), timeout=5.0)
             final_yield = parse_output(final_result)
+            log.info(f"Got final result: {type(final_yield)}")
+        except asyncio.TimeoutError:
+            log.warning("Timeout waiting for final result from queue")
+            final_yield = ""
         except asyncio.QueueEmpty:
+            log.warning("Queue empty when trying to get final result")
             final_yield = ""
 
     # Match the non-async behavior - yield the parsed output directly, not as JSON
-    yield final_yield
+    if final_yield:  # Only yield if we have actual content
+        log.info(f"Yielding final_yield: type={type(final_yield)}, is_dict={isinstance(final_yield, dict)}, keys={list(final_yield.keys()) if isinstance(final_yield, dict) else 'N/A'}")
+        yield final_yield
+    else:
+        log.info("Final yield was empty, not yielding")
 
 
 def generate_proxy_stream(stream_to_f, user_input, vector_name, chat_history, generate_f_output, **kwargs):

{sunholo-0.143.16.dist-info → sunholo-0.144.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.16
+Version: 0.144.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
@@ -12,26 +12,22 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: a2a-python>=0.0.1
-Requires-Dist: aiohttp
-Requires-Dist: flask>=3.1.0
 Requires-Dist: google-auth
-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
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Provides-Extra: all
+Requires-Dist: a2a-python>=0.0.1; extra == "all"
 Requires-Dist: aiofiles; extra == "all"
 Requires-Dist: aiohttp; extra == "all"
 Requires-Dist: anthropic[vertex]; extra == "all"
@@ -39,7 +35,8 @@ Requires-Dist: asyncpg; extra == "all"
 Requires-Dist: azure-identity; extra == "all"
 Requires-Dist: azure-storage-blob; extra == "all"
 Requires-Dist: fastapi; extra == "all"
-Requires-Dist: flask; extra == "all"
+Requires-Dist: fastmcp>=2.12.0; extra == "all"
+Requires-Dist: flask>=3.1.0; extra == "all"
 Requires-Dist: google-auth; extra == "all"
 Requires-Dist: google-auth-httplib2; extra == "all"
 Requires-Dist: google-auth-oauthlib; extra == "all"
@@ -82,6 +79,9 @@ Requires-Dist: psutil; extra == "all"
 Requires-Dist: psycopg2-binary; extra == "all"
 Requires-Dist: pydantic; extra == "all"
 Requires-Dist: pypdf; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
 Requires-Dist: python-hcl2; extra == "all"
 Requires-Dist: python-socketio; extra == "all"
 Requires-Dist: pytesseract; extra == "all"
@@ -127,7 +127,7 @@ Requires-Dist: pytesseract; extra == "pipeline"
 Requires-Dist: tabulate; extra == "pipeline"
 Requires-Dist: unstructured[all-docs,local-inference]; extra == "pipeline"
 Provides-Extra: gcp
-Requires-Dist: a2a-python; extra == "gcp"
+Requires-Dist: a2a-python>=0.0.1; extra == "gcp"
 Requires-Dist: aiofiles; extra == "gcp"
 Requires-Dist: anthropic[vertex]; extra == "gcp"
 Requires-Dist: google-api-python-client; extra == "gcp"
@@ -157,14 +157,16 @@ Provides-Extra: openai
 Requires-Dist: langchain-openai>=0.3.2; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
 Provides-Extra: anthropic
+Requires-Dist: fastmcp>=2.12.0; extra == "anthropic"
 Requires-Dist: langchain-anthropic>=0.1.23; 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"
 Provides-Extra: http
+Requires-Dist: aiohttp; extra == "http"
 Requires-Dist: fastapi; extra == "http"
-Requires-Dist: flask; extra == "http"
+Requires-Dist: flask>=3.1.0; extra == "http"
 Requires-Dist: gunicorn; extra == "http"
 Requires-Dist: httpcore; extra == "http"
 Requires-Dist: httpx; extra == "http"

{sunholo-0.143.16.dist-info → sunholo-0.144.1.dist-info}/RECORD

@@ -7,15 +7,16 @@ sunholo/a2a/task_manager.py,sha256=Ox1oAHarqYdcWku_JFcYDt2pQG3gwfuBTO7WCakE-U0,1
 sunholo/a2a/vac_a2a_agent.py,sha256=vL-sQceVRBE9d3kjx9m8zGWK1S9J1sHUybAH3tSbVFg,13344
 sunholo/agents/__init__.py,sha256=AauG3l0y4r5Fzx1zJfZ634M4o-0o7B7J5T8k_gPvNqE,370
 sunholo/agents/chat_history.py,sha256=gRuIUyU-53A72Q17SmSgf6Ok3YO8hKAZhsc64976018,17782
-sunholo/agents/dispatch_to_qa.py,sha256=NHihwAoCJ5_Lk11e_jZnucVUGQyZHCB-YpkfMHBCpQk,8882
+sunholo/agents/dispatch_to_qa.py,sha256=Q5i3S1GMRN_zbT15WLhkiZzGn2ebbGQJv5oqRGhmyBI,9243
 sunholo/agents/langserve.py,sha256=C46ph2mnygr6bdHijYWYyfQDI9ylAF0_9Kx2PfcCJpU,4414
 sunholo/agents/pubsub.py,sha256=TscZN_6am6DfaQkC-Yl18ZIBOoLE-0nDSiil6GpQEh4,1344
 sunholo/agents/route.py,sha256=mV8tGABbSqcg3PQL02MgQOs41gKEHLMyIJJJcTuFdbE,2988
 sunholo/agents/special_commands.py,sha256=-9reLRZtTFMuivY4JLk6FDLi5Pf6lphn4SJlSPuMVsE,6492
 sunholo/agents/swagger.py,sha256=2tzGmpveUMmTREykZvVnDj3j295wyOMu7mUFDnXdY3c,10671
-sunholo/agents/fastapi/__init__.py,sha256=S_pj4_bTUmDGoq_exaREHlOKThi0zTuGT0VZY0YfODQ,88
+sunholo/agents/fastapi/__init__.py,sha256=f7x7kiEjaNyBiOwJHLJ4vdOiePqkXdI52sIAAHtS-ms,141
 sunholo/agents/fastapi/base.py,sha256=W-cyF8ZDUH40rc-c-Apw3-_8IIi2e4Y9qRtnoVnsc1Q,2521
 sunholo/agents/fastapi/qna_routes.py,sha256=lKHkXPmwltu9EH3RMwmD153-J6pE7kWQ4BhBlV3to-s,3864
+sunholo/agents/fastapi/vac_routes.py,sha256=sK2FuJsOBgc8sIKtTOYuyhNql5JX63U_hMpQQ-nLcug,42985
 sunholo/agents/flask/__init__.py,sha256=dEoByI3gDNUOjpX1uVKP7uPjhfFHJubbiaAv3xLopnk,63
 sunholo/agents/flask/base.py,sha256=vnpxFEOnCmt9humqj-jYPLfJcdwzsop9NorgkJ-tSaU,1756
 sunholo/agents/flask/vac_routes.py,sha256=kaPUDyIH5KhCgeCEtag97qErGVZfqpY1ZEiX3y1_r-s,57505
@@ -115,10 +116,12 @@ sunholo/llamaindex/user_history.py,sha256=ZtkecWuF9ORduyGB8kF8gP66bm9DdvCI-ZiK6K
 sunholo/lookup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/lookup/model_lookup.yaml,sha256=O7o-jP53MLA06C8pI-ILwERShO-xf6z_258wtpZBv6A,739
 sunholo/mcp/__init__.py,sha256=Bi0ZYMvWuf1AL_QSrMAREVVdTZFiIokGwrytBXKBJyc,1028
-sunholo/mcp/cli.py,sha256=zVbUDrOS1kvSMYJvq7PqzYnEwwzP1sGE0YWwhpVd_VM,12255
+sunholo/mcp/cli.py,sha256=RyTrTBQMUaNMAZ1Nyh-XKb9qGnCA5hMxpKp5-9lqfrI,821
+sunholo/mcp/cli_fastmcp.py,sha256=MWx7kJ4RHX0tTygWs247aOYr4bCKOwjnmccOPjcTVnc,6104
 sunholo/mcp/mcp_manager.py,sha256=g75vv6XvM24U7uz366slE-p76Qs4AvVcsarHSF9qIvE,5061
 sunholo/mcp/stdio_http_bridge.py,sha256=IunHOtnjKAkRWef3SJnqnAL2r2qBRpCH2k_Q_y0Tdf8,3237
-sunholo/mcp/vac_mcp_server.py,sha256=WcFOgN2_lyp1vfn-KcW4GewrBidkRYDx9gzEORV6rV8,10611
+sunholo/mcp/vac_mcp_server.py,sha256=MotoCw5lDsxCeVtwh1499yGFku9w-78xXhGkIHTUo3w,838
+sunholo/mcp/vac_mcp_server_fastmcp.py,sha256=Po8Uvs1iSYKNfB5Qz5B7URU9i4jEW70wPpJZDEbAO1U,7430
 sunholo/ollama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/ollama/ollama_images.py,sha256=H2cpcNu88R4TwyfL_nnqkQhdvBQ2FPCAy4Ok__0yQmo,2351
 sunholo/pubsub/__init__.py,sha256=DfTEk4zmCfqn6gFxRrqDO0pOrvXTDqH-medpgYO4PGw,117
@@ -133,7 +136,7 @@ sunholo/streaming/__init__.py,sha256=MpbydI2UYo_adttPQFkxNM33b-QRyNEbrKJx0C2AGPc
 sunholo/streaming/content_buffer.py,sha256=bqPta3Q1tXI88Ngyj1kgPC-v4phhGm1nZURcuqQSGIQ,12537
 sunholo/streaming/langserve.py,sha256=hi7q8WY8DPKrALl9m_dOMxWOdE-iEuk7YW05SVDFIX8,6514
 sunholo/streaming/stream_lookup.py,sha256=hYg1DbdSE_QNJ8ZB-ynXJlWgvFjrGvwoUsGJu_E0pRQ,360
-sunholo/streaming/streaming.py,sha256=2KgiiCZl0nGZQDF1oO7gti3e3_cPlomLRkQGGMNj0qQ,17203
+sunholo/streaming/streaming.py,sha256=P0zQoTIjOrW5-lNwZ1mrxtEqAVgFdINZ7tnwNGHQnwY,18390
 sunholo/summarise/__init__.py,sha256=MZk3dblUMODcPb1crq4v-Z508NrFIpkSWNf9FIO8BcU,38
 sunholo/summarise/summarise.py,sha256=UnycBVLLEXK1HitCOG2zW3XIyxMrw47xoVf6e2OC9A0,4150
 sunholo/templates/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -176,9 +179,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.143.16.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.143.16.dist-info/METADATA,sha256=U3OPOEIEC-Dvnjni6sM10RgsnYk5sczbbQD2cP252Yc,18502
-sunholo-0.143.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sunholo-0.143.16.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.143.16.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.143.16.dist-info/RECORD,,
+sunholo-0.144.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.144.1.dist-info/METADATA,sha256=ia-s14a5R5yxApJZGGqqeT2ebAlxEyc5AJhniD9xtxg,18700
+sunholo-0.144.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sunholo-0.144.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.144.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.144.1.dist-info/RECORD,,