windows-mcp 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

windows_mcp/__main__.py

@@ -1,11 +1,10 @@
 from windows_mcp.analytics import PostHogAnalytics, with_analytics
-from live_inspect.watch_cursor import WatchCursor
-from windows_mcp.desktop.service import Desktop
+from windows_mcp.desktop.service import Desktop,Size
+from windows_mcp.watchdog.service import WatchDog
 from contextlib import asynccontextmanager
 from fastmcp.utilities.types import Image
 from mcp.types import ToolAnnotations
 from typing import Literal, Optional
-from humancursor import SystemCursor
 from fastmcp import FastMCP, Context
 from dotenv import load_dotenv
 from textwrap import dedent
@@ -16,46 +15,50 @@ import os
 
 load_dotenv()
 
+MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT = 1920, 1080
 pg.FAILSAFE=False
 pg.PAUSE=1.0
 
-desktop=Desktop()
-cursor=SystemCursor()
-watch_cursor=WatchCursor()
-windows_version=desktop.get_windows_version()
-default_language=desktop.get_default_language()
-screen_width,screen_height=desktop.get_resolution()
+desktop: Optional[Desktop] = None
+watchdog: Optional[WatchDog] = None
+analytics: Optional[PostHogAnalytics] = None
+screen_size:Optional[Size]=None
 
 instructions=dedent(f'''
-Windows MCP server provides tools to interact directly with the {windows_version} desktop, 
+Windows MCP server provides tools to interact directly with the Windows desktop, 
 thus enabling to operate the desktop on the user's behalf.
 ''')
 
-# Initialize analytics at module level to be used in decorators
-if os.getenv("ANONYMIZED_TELEMETRY", "true").lower() == "false":
-    analytics = None
-else:
-    analytics = PostHogAnalytics()
-
 @asynccontextmanager
 async def lifespan(app: FastMCP):
     """Runs initialization code before the server starts and cleanup code after it shuts down."""
+    global desktop, watchdog, analytics,screen_size
+    
+    # Initialize components here instead of at module level
+    if os.getenv("ANONYMIZED_TELEMETRY", "true").lower() != "false":
+        analytics = PostHogAnalytics()
+    desktop = Desktop()
+    watchdog = WatchDog()   
+    screen_size=desktop.get_screen_size()
+    watchdog.set_focus_callback(desktop.tree._on_focus_change)
+    
     try:
-        watch_cursor.start()
+        watchdog.start()
         await asyncio.sleep(1) # Simulate startup latency
         yield
     finally:
-        watch_cursor.stop()
+        if watchdog:
+            watchdog.stop()
         if analytics:
             await analytics.close()
 
 mcp=FastMCP(name='windows-mcp',instructions=instructions,lifespan=lifespan)
 
 @mcp.tool(
-    name="App-Tool",
+    name="App",
     description="Manages Windows applications with three modes: 'launch' (start app by name), 'resize' (set window position/size using window_loc=[x,y] and window_size=[width,height]), 'switch' (activate app by name). Essential for application lifecycle management.",
     annotations=ToolAnnotations(
-        title="App Tool",
+        title="App",
         readOnlyHint=False,
         destructiveHint=True,
         idempotentHint=False,
@@ -67,10 +70,10 @@ def app_tool(mode:Literal['launch','resize','switch'],name:str|None=None,window_
     return desktop.app(mode,name,window_loc,window_size)
     
 @mcp.tool(
-    name='Powershell-Tool',
-    description='Execute PowerShell commands directly on the Windows system and return output with status code. Supports all PowerShell cmdlets, scripts, and system commands. Use for file operations, system queries, and administrative tasks.',
+    name='Shell',
+    description='A comprehensive system tool for executing any PowerShell commands. Use it to navigate the file system, manage files and processes, and execute system-level operations. Capable of accessing web content (e.g., via Invoke-WebRequest), interacting with network resources, and performing complex administrative tasks. This tool provides full access to the underlying operating system capabilities, making it the primary interface for system automation, scripting, and deep system interaction.',
     annotations=ToolAnnotations(
-        title="Powershell Tool",
+        title="Shell",
         readOnlyHint=False,
         destructiveHint=True,
         idempotentHint=False,
@@ -78,15 +81,15 @@ def app_tool(mode:Literal['launch','resize','switch'],name:str|None=None,window_
     )
     )
 @with_analytics(analytics, "Powershell-Tool")
-def powershell_tool(command: str, ctx: Context = None) -> str:
-    response,status_code=desktop.execute_command(command)
+def powershell_tool(command: str,timeout:int=10, ctx: Context = None) -> str:
+    response,status_code=desktop.execute_command(command,timeout)
     return f'Response: {response}\nStatus Code: {status_code}'
 
 @mcp.tool(
-    name='State-Tool',
+    name='Snapshot',
     description='Captures complete desktop state including: system language, focused/opened apps, interactive elements (buttons, text fields, links, menus with coordinates), and scrollable areas. Set use_vision=True to include screenshot. Set use_dom=True for browser content to get web page elements instead of browser UI. Always call this first to understand the current desktop state before taking actions.',
     annotations=ToolAnnotations(
-        title="State Tool",
+        title="Snapshot",
         readOnlyHint=True,
         destructiveHint=False,
         idempotentHint=True,
@@ -96,9 +99,8 @@ def powershell_tool(command: str, ctx: Context = None) -> str:
 @with_analytics(analytics, "State-Tool")
 def state_tool(use_vision:bool=False,use_dom:bool=False, ctx: Context = None):
     # Calculate scale factor to cap resolution at 1080p (1920x1080)
-    max_width, max_height = 1920, 1080
-    scale_width = max_width / screen_width if screen_width > max_width else 1.0
-    scale_height = max_height / screen_height if screen_height > max_height else 1.0
+    scale_width = MAX_IMAGE_WIDTH / screen_size.width if screen_size.width > MAX_IMAGE_WIDTH else 1.0
+    scale_height = MAX_IMAGE_HEIGHT / screen_size.height if screen_size.height > MAX_IMAGE_HEIGHT else 1.0
     scale = min(scale_width, scale_height)  # Use the smaller scale to ensure both dimensions fit
     
     desktop_state=desktop.get_state(use_vision=use_vision,use_dom=use_dom,as_bytes=True,scale=scale)
@@ -106,10 +108,7 @@ def state_tool(use_vision:bool=False,use_dom:bool=False, ctx: Context = None):
     scrollable_elements=desktop_state.tree_state.scrollable_elements_to_string()
     apps=desktop_state.apps_to_string()
     active_app=desktop_state.active_app_to_string()
-    return [dedent(f'''
-    Default Language of User:
-    {default_language} with encoding: {desktop.encoding}
-                            
+    return [dedent(f'''        
     Focused App:
     {active_app}
 
@@ -124,10 +123,10 @@ def state_tool(use_vision:bool=False,use_dom:bool=False, ctx: Context = None):
     ''')]+([Image(data=desktop_state.screenshot,format='png')] if use_vision else [])
 
 @mcp.tool(
-    name='Click-Tool',
+    name='Click',
     description='Performs mouse clicks at specified coordinates [x, y]. Supports button types: left (default), right (context menu), middle. Supports clicks: 1 (single), 2 (double), 3 (triple). Always use coordinates from State-Tool output to ensure accuracy.',
     annotations=ToolAnnotations(
-        title="Click Tool",
+        title="Click",
         readOnlyHint=False,
         destructiveHint=True,
         idempotentHint=False,
@@ -144,10 +143,10 @@ def click_tool(loc:list[int],button:Literal['left','right','middle']='left',clic
     return f'{num_clicks.get(clicks)} {button} clicked at ({x},{y}).'
 
 @mcp.tool(
-    name='Type-Tool',
+    name='Type',
     description='Types text at specified coordinates [x, y]. Set clear=True to clear existing text first (Ctrl+A then type), clear=False to append. Set press_enter=True to submit after typing. Always click on the target input field first to ensure focus.',
     annotations=ToolAnnotations(
-        title="Type Tool",
+        title="Type",
         readOnlyHint=False,
         destructiveHint=True,
         idempotentHint=False,
@@ -163,10 +162,10 @@ def type_tool(loc:list[int],text:str,clear:bool=False,press_enter:bool=False, ct
     return f'Typed {text} at ({x},{y}).'
 
 @mcp.tool(
-    name='Scroll-Tool',
+    name='Scroll',
     description='Scrolls at coordinates [x, y] or current mouse position if loc=None. Type: vertical (default) or horizontal. Direction: up/down for vertical, left/right for horizontal. wheel_times controls amount (1 wheel ≈ 3-5 lines). Use for navigating long content, lists, and web pages.',
     annotations=ToolAnnotations(
-        title="Scroll Tool",
+        title="Scroll",
         readOnlyHint=False,
         destructiveHint=False,
         idempotentHint=True,
@@ -183,29 +182,10 @@ def scroll_tool(loc:list[int]=None,type:Literal['horizontal','vertical']='vertic
     return f'Scrolled {type} {direction} by {wheel_times} wheel times'+f' at ({loc[0]},{loc[1]}).' if loc else ''
 
 @mcp.tool(
-    name='Drag-Tool',
-    description='Performs drag-and-drop from current mouse position to destination coordinates [x, y]. Click or move to source position first, then call this tool with target coordinates. Use for moving files, reordering items, resizing windows, or any drag-drop UI interactions.',
-    annotations=ToolAnnotations(
-        title="Drag Tool",
-        readOnlyHint=False,
-        destructiveHint=True,
-        idempotentHint=False,
-        openWorldHint=False
-    )
-    )
-@with_analytics(analytics, "Drag-Tool")
-def drag_tool(to_loc:list[int], ctx: Context = None)->str:
-    if len(to_loc) != 2:
-        raise ValueError("to_loc must be a list of exactly 2 integers [x, y]")
-    desktop.drag(to_loc)
-    x2,y2=to_loc[0],to_loc[1]
-    return f'Dragged the element to ({x2},{y2}).'
-
-@mcp.tool(
-    name='Move-Tool',
-    description='Moves mouse cursor to coordinates [x, y] without clicking. Use for hovering to reveal tooltips/menus, positioning cursor before drag operations, or triggering hover-based UI changes. Does not interact with elements.',
+    name='Move',
+    description='Moves mouse cursor to coordinates [x, y]. Set drag=True to perform a drag-and-drop operation from the current mouse position to the target coordinates. Default (drag=False) is a simple cursor move (hover).',
     annotations=ToolAnnotations(
-        title="Move Tool",
+        title="Move",
         readOnlyHint=False,
         destructiveHint=False,
         idempotentHint=True,
@@ -213,18 +193,22 @@ def drag_tool(to_loc:list[int], ctx: Context = None)->str:
     )
     )
 @with_analytics(analytics, "Move-Tool")
-def move_tool(to_loc:list[int], ctx: Context = None)->str:
-    if len(to_loc) != 2:
-        raise ValueError("to_loc must be a list of exactly 2 integers [x, y]")
-    x,y=to_loc[0],to_loc[1]
-    desktop.move(to_loc)
-    return f'Moved the mouse pointer to ({x},{y}).'
+def move_tool(loc:list[int], drag:bool=False, ctx: Context = None)->str:
+    if len(loc) != 2:
+        raise ValueError("loc must be a list of exactly 2 integers [x, y]")
+    x,y=loc[0],loc[1]
+    if drag:
+        desktop.drag(loc)
+        return f'Dragged to ({x},{y}).'
+    else:
+        desktop.move(loc)
+        return f'Moved the mouse pointer to ({x},{y}).'
 
 @mcp.tool(
-    name='Shortcut-Tool',
+    name='Shortcut',
     description='Executes keyboard shortcuts using key combinations separated by +. Examples: "ctrl+c" (copy), "ctrl+v" (paste), "alt+tab" (switch apps), "win+r" (Run dialog), "win" (Start menu), "ctrl+shift+esc" (Task Manager). Use for quick actions and system commands.',
     annotations=ToolAnnotations(
-        title="Shortcut Tool",
+        title="Shortcut",
         readOnlyHint=False,
         destructiveHint=True,
         idempotentHint=False,
@@ -237,10 +221,10 @@ def shortcut_tool(shortcut:str, ctx: Context = None):
     return f"Pressed {shortcut}."
 
 @mcp.tool(
-    name='Wait-Tool',
+    name='Wait',
     description='Pauses execution for specified duration in seconds. Use when waiting for: applications to launch/load, UI animations to complete, page content to render, dialogs to appear, or between rapid actions. Helps ensure UI is ready before next interaction.',
     annotations=ToolAnnotations(
-        title="Wait Tool",
+        title="Wait",
         readOnlyHint=True,
         destructiveHint=False,
         idempotentHint=True,
@@ -253,10 +237,10 @@ def wait_tool(duration:int, ctx: Context = None)->str:
     return f'Waited for {duration} seconds.'
 
 @mcp.tool(
-    name='Scrape-Tool',
-    description='Fetch content from a URL or the active browser tab. By default (use_dom=False), performs a lightweight HTTP request to the URL and returns markdown content of complete webpage. Note: Some websites may block automated HTTP requests. If this fails, open the page in a browser and retry with use_dom=True to extract visible text from the active tab\'s DOM within the viewport.',
+    name='Scrape',
+    description='Fetch content from a URL or the active browser tab. By default (use_dom=False), performs a lightweight HTTP request to the URL and returns markdown content of complete webpage. Note: Some websites may block automated HTTP requests. If this fails, open the page in a browser and retry with use_dom=True to extract visible text from the active tab\'s DOM within the viewport using the accessibility tree data.',
     annotations=ToolAnnotations(
-        title="Scrape Tool",
+        title="Scrape",
         readOnlyHint=True,
         destructiveHint=False,
         idempotentHint=True,
@@ -271,10 +255,10 @@ def scrape_tool(url:str,use_dom:bool=False, ctx: Context = None)->str:
 
     desktop_state=desktop.get_state(use_vision=False,use_dom=use_dom)
     tree_state=desktop_state.tree_state
-    if not tree_state.dom_info:
+    if not tree_state.dom_node:
         return f'No DOM information found. Please open {url} in browser first.'
-    dom_info=tree_state.dom_info
-    vertical_scroll_percent=dom_info.vertical_scroll_percent
+    dom_node=tree_state.dom_node
+    vertical_scroll_percent=dom_node.vertical_scroll_percent
     content='\n'.join([node.text for node in tree_state.dom_informative_nodes])
     header_status = "Reached top" if vertical_scroll_percent <= 0 else "Scroll up to see more"
     footer_status = "Reached bottom" if vertical_scroll_percent >= 100 else "Scroll down to see more"
@@ -303,10 +287,13 @@ def scrape_tool(url:str,use_dom:bool=False, ctx: Context = None)->str:
     show_default=True
 )
 def main(transport, host, port):
-    if transport=='stdio':
-        mcp.run()
-    else:
-        mcp.run(transport=transport,host=host,port=port)
+    match transport:
+        case 'stdio':
+            mcp.run(transport=transport,show_banner=False)
+        case 'sse'|'streamable-http':
+            mcp.run(transport=transport,host=host,port=port,show_banner=False)
+        case _:
+            raise ValueError(f"Invalid transport: {transport}")
 
 if __name__ == "__main__":
     main()

windows_mcp/analytics.py

@@ -1,171 +1,170 @@
-from typing import Optional, Dict, Any, TypeVar, Callable, Protocol, Awaitable
-from tempfile import TemporaryDirectory
-from uuid_extensions import uuid7str
-from fastmcp import Context
-from functools import wraps
-from pathlib import Path
-import posthog
-import asyncio
-import logging
-import time
-import os
-
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-T = TypeVar("T")
-
-class Analytics(Protocol):
-    async def track_tool(self, tool_name: str, result: Dict[str, Any]) -> None:
-        """Tracks the execution of a tool."""
-        ...
-
-    async def track_error(self, error: Exception, context: Dict[str, Any]) -> None:
-        """Tracks an error that occurred during the execution of a tool."""
-        ...
-
-    async def is_feature_enabled(self, feature: str) -> bool:
-        """Checks if a feature flag is enabled."""
-        ...
-
-    async def close(self) -> None:
-        """Closes the analytics client."""
-        ...
-
-class PostHogAnalytics:
-    TEMP_FOLDER = Path(TemporaryDirectory().name).parent
-    API_KEY = 'phc_uxdCItyVTjXNU0sMPr97dq3tcz39scQNt3qjTYw5vLV'
-    HOST = 'https://us.i.posthog.com'
-
-    def __init__(self):
-        self.client = posthog.Posthog(
-            self.API_KEY, 
-            host=self.HOST, 
-            disable_geoip=False, 
-            enable_exception_autocapture=True,
-            debug=True
-        )
-        self._user_id = None
-        self.mcp_interaction_id = f"mcp_{int(time.time()*1000)}_{os.getpid()}"
-        
-        if self.client:
-            logger.debug(f"Initialized with user ID: {self.user_id} and session ID: {self.mcp_interaction_id}")
-
-    @property
-    def user_id(self) -> str:
-        if self._user_id:
-            return self._user_id
-            
-        user_id_file = self.TEMP_FOLDER / '.windows-mcp-user-id'
-        if user_id_file.exists():
-            self._user_id = user_id_file.read_text(encoding='utf-8').strip()
-        else:
-            self._user_id = uuid7str()
-            try:
-                user_id_file.write_text(self._user_id, encoding='utf-8')
-            except Exception as e:
-                logger.warning(f"Could not persist user ID: {e}")
-                
-        return self._user_id
-
-    async def track_tool(self, tool_name: str, result: Dict[str, Any]) -> None:
-        if self.client:
-            self.client.capture(
-                distinct_id=self.user_id,
-                event="tool_executed",
-                properties={
-                    "tool_name": tool_name, 
-                    "session_id": self.mcp_interaction_id,
-                    "process_person_profile": True,
-                    **result
-                }
-            )
-        
-        duration = result.get("duration_ms", 0)
-        success_mark = "SUCCESS" if result.get("success") else "FAILED"
-        # Using print for immediate visibility in console during debugging
-        print(f"[Analytics] {tool_name}: {success_mark} ({duration}ms)")
-        logger.info(f"{tool_name}: {success_mark} ({duration}ms)")
-        if self.client:
-            self.client.flush()
-
-    async def track_error(self, error: Exception, context: Dict[str, Any]) -> None:
-        if self.client:
-            self.client.capture(
-                 distinct_id=self.user_id,
-                 event="exception",
-                 properties={
-                     "exception": str(error),
-                     "traceback": str(error) if not hasattr(error, '__traceback__') else str(error),
-                     "session_id": self.mcp_interaction_id,
-                     "process_person_profile": True,
-                     **context
-                 }
-            )
-        
-        if self.client:
-            self.client.flush()
-        
-        logger.error(f"ERROR in {context.get('tool_name')}: {error}")
-
-    async def is_feature_enabled(self, feature: str) -> bool:
-        if not self.client:
-            return False
-        return self.client.is_feature_enabled(feature, self.user_id)
-
-    async def close(self) -> None:
-        if self.client:
-            self.client.shutdown()
-            logger.debug("Closed analytics")
-
-def with_analytics(analytics_instance: Optional[Analytics], tool_name: str):
-    """
-    Decorator to wrap tool functions with analytics tracking.
-    """
-    def decorator(func: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]:
-        @wraps(func)
-        async def wrapper(*args, **kwargs) -> T:
-            start = time.time()
-            
-            # Capture client info from Context passed as argument
-            client_data = {}
-            try:
-                ctx = next((arg for arg in args if isinstance(arg, Context)), None)
-                if not ctx:
-                    ctx = next((val for val in kwargs.values() if isinstance(val, Context)), None)
-
-                if ctx and ctx.session and ctx.session.client_params and ctx.session.client_params.clientInfo:
-                    info = ctx.session.client_params.clientInfo
-                    client_data["client_name"] = info.name
-                    client_data["client_version"] = info.version
-            except Exception:
-                pass
-
-            try:
-                if asyncio.iscoroutinefunction(func):
-                    result = await func(*args, **kwargs)
-                else:
-                    # Run sync function in thread to avoid blocking loop
-                    result = await asyncio.to_thread(func, *args, **kwargs)
-
-                duration_ms = int((time.time() - start) * 1000)
-                
-                if analytics_instance:
-                    await analytics_instance.track_tool(tool_name, {
-                        "duration_ms": duration_ms, 
-                        "success": True, 
-                        **client_data
-                    })
-                
-                return result
-            except Exception as error:
-                duration_ms = int((time.time() - start) * 1000)
-                if analytics_instance:
-                    await analytics_instance.track_error(error, {
-                        "tool_name": tool_name,
-                        "duration_ms": duration_ms,
-                        **client_data
-                    })
-                raise error
-        return wrapper
-    return decorator
+from typing import Optional, Dict, Any, TypeVar, Callable, Protocol, Awaitable
+from tempfile import TemporaryDirectory
+from uuid_extensions import uuid7str
+from fastmcp import Context
+from functools import wraps
+from pathlib import Path
+import posthog
+import asyncio
+import logging
+import time
+import os
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+formatter = logging.Formatter('[%(levelname)s] %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+T = TypeVar("T")
+
+class Analytics(Protocol):
+    async def track_tool(self, tool_name: str, result: Dict[str, Any]) -> None:
+        """Tracks the execution of a tool."""
+        ...
+
+    async def track_error(self, error: Exception, context: Dict[str, Any]) -> None:
+        """Tracks an error that occurred during the execution of a tool."""
+        ...
+
+    async def is_feature_enabled(self, feature: str) -> bool:
+        """Checks if a feature flag is enabled."""
+        ...
+
+    async def close(self) -> None:
+        """Closes the analytics client."""
+        ...
+
+class PostHogAnalytics:
+    TEMP_FOLDER = Path(TemporaryDirectory().name).parent
+    API_KEY = 'phc_uxdCItyVTjXNU0sMPr97dq3tcz39scQNt3qjTYw5vLV'
+    HOST = 'https://us.i.posthog.com'
+
+    def __init__(self):
+        self.client = posthog.Posthog(
+            self.API_KEY, 
+            host=self.HOST, 
+            disable_geoip=False, 
+            enable_exception_autocapture=True,
+            debug=False
+        )
+        self._user_id = None
+        self.mcp_interaction_id = f"mcp_{int(time.time()*1000)}_{os.getpid()}"
+        
+        if self.client:
+            logger.debug(f"Initialized with user ID: {self.user_id} and session ID: {self.mcp_interaction_id}")
+
+    @property
+    def user_id(self) -> str:
+        if self._user_id:
+            return self._user_id
+            
+        user_id_file = self.TEMP_FOLDER / '.windows-mcp-user-id'
+        if user_id_file.exists():
+            self._user_id = user_id_file.read_text(encoding='utf-8').strip()
+        else:
+            self._user_id = uuid7str()
+            try:
+                user_id_file.write_text(self._user_id, encoding='utf-8')
+            except Exception as e:
+                logger.warning(f"Could not persist user ID: {e}")
+                
+        return self._user_id
+
+    async def track_tool(self, tool_name: str, result: Dict[str, Any]) -> None:
+        if self.client:
+            self.client.capture(
+                distinct_id=self.user_id,
+                event="tool_executed",
+                properties={
+                    "tool_name": tool_name, 
+                    "session_id": self.mcp_interaction_id,
+                    "process_person_profile": True,
+                    **result
+                }
+            )
+        
+        duration = result.get("duration_ms", 0)
+        success_mark = "SUCCESS" if result.get("success") else "FAILED"
+        # Using print for immediate visibility in console during debugging
+        print(f"[Analytics] {tool_name}: {success_mark} ({duration}ms)")
+        logger.info(f"{tool_name}: {success_mark} ({duration}ms)")
+
+    async def track_error(self, error: Exception, context: Dict[str, Any]) -> None:
+        if self.client:
+            self.client.capture(
+                 distinct_id=self.user_id,
+                 event="exception",
+                 properties={
+                     "exception": str(error),
+                     "traceback": str(error) if not hasattr(error, '__traceback__') else str(error),
+                     "session_id": self.mcp_interaction_id,
+                     "process_person_profile": True,
+                     **context
+                 }
+            )
+        
+        logger.error(f"ERROR in {context.get('tool_name')}: {error}")
+
+    async def is_feature_enabled(self, feature: str) -> bool:
+        if not self.client:
+            return False
+        return self.client.is_feature_enabled(feature, self.user_id)
+
+    async def close(self) -> None:
+        if self.client:
+            self.client.shutdown()
+            logger.debug("Closed analytics")
+
+def with_analytics(analytics_instance: Optional[Analytics], tool_name: str):
+    """
+    Decorator to wrap tool functions with analytics tracking.
+    """
+    def decorator(func: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]:
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> T:
+            start = time.time()
+            
+            # Capture client info from Context passed as argument
+            client_data = {}
+            try:
+                ctx = next((arg for arg in args if isinstance(arg, Context)), None)
+                if not ctx:
+                    ctx = next((val for val in kwargs.values() if isinstance(val, Context)), None)
+
+                if ctx and ctx.session and ctx.session.client_params and ctx.session.client_params.clientInfo:
+                    info = ctx.session.client_params.clientInfo
+                    client_data["client_name"] = info.name
+                    client_data["client_version"] = info.version
+            except Exception:
+                pass
+
+            try:
+                if asyncio.iscoroutinefunction(func):
+                    result = await func(*args, **kwargs)
+                else:
+                    # Run sync function in thread to avoid blocking loop
+                    result = await asyncio.to_thread(func, *args, **kwargs)
+
+                duration_ms = int((time.time() - start) * 1000)
+                
+                if analytics_instance:
+                    await analytics_instance.track_tool(tool_name, {
+                        "duration_ms": duration_ms, 
+                        "success": True, 
+                        **client_data
+                    })
+                
+                return result
+            except Exception as error:
+                duration_ms = int((time.time() - start) * 1000)
+                if analytics_instance:
+                    await analytics_instance.track_error(error, {
+                        "tool_name": tool_name,
+                        "duration_ms": duration_ms,
+                        **client_data
+                    })
+                raise error
+        return wrapper
+    return decorator