minitap-mcp 0.9.0__tar.gz → 0.9.2__tar.gz

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: minitap-mcp
-Version: 0.9.0
+Version: 0.9.2
 Summary: Model Context Protocol server for controlling Android & iOS devices with natural language
 Author: Pierre-Louis Favreau, Jean-Pierre Lo, Clément Guiguet
 Requires-Dist: fastmcp>=2.12.4
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: pydantic>=2.12.0
 Requires-Dist: pydantic-settings>=2.10.1
-Requires-Dist: minitap-mobile-use>=3.4.0
+Requires-Dist: minitap-mobile-use>=3.5.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: langchain-core>=0.3.75
 Requires-Dist: pillow>=11.1.0

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/core/agents/compare_screenshots/agent.py

@@ -1,5 +1,4 @@
 import asyncio
-import base64
 from pathlib import Path
 from uuid import uuid4
 
@@ -10,7 +9,6 @@ from pydantic import BaseModel
 from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.core.llm import get_minitap_llm
 from minitap.mcp.core.utils.images import get_screenshot_message_for_llm
-from minitap.mcp.server.cloud_mobile import get_cloud_mobile_id, get_cloud_screenshot
 
 
 class CompareScreenshotsOutput(BaseModel):
@@ -25,7 +23,7 @@ async def compare_screenshots(
     """
     Compare screenshots and return the comparison text along with both screenshots.
 
-    Supports both local devices (Android/iOS) and cloud devices.
+    Captures screenshot from local device and compares with expected screenshot.
 
     Returns:
         CompareScreenshotsOutput
@@ -34,14 +32,8 @@ async def compare_screenshots(
         Path(__file__).parent.joinpath("prompt.md").read_text(encoding="utf-8")
     ).render()
 
-    cloud_mobile_id = get_cloud_mobile_id()
-
-    if cloud_mobile_id:
-        screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
-        current_screenshot = base64.b64encode(screenshot_bytes).decode("utf-8")
-    else:
-        device = find_mobile_device()
-        current_screenshot = capture_screenshot(device)
+    device = find_mobile_device()
+    current_screenshot = capture_screenshot(device)
 
     messages: list[BaseMessage] = [
         SystemMessage(content=system_message),

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/core/config.py

@@ -62,11 +62,11 @@ class MCPSettings(BaseSettings):
     MCP_SERVER_HOST: str = Field(default="0.0.0.0")
     MCP_SERVER_PORT: int = Field(default=8000)
 
-    # Cloud Mobile configuration
-    # When set, the MCP server runs in cloud mode connecting to a Minitap cloud mobile
-    # instead of requiring a local device. Value can be a device name.
-    # Create cloud mobiles at https://platform.minitap.ai/cloud-mobiles
-    CLOUD_MOBILE_NAME: str | None = Field(default=None)
+    # Local device configuration
+    # When False, disables the local device health poller.
+    # Useful when running the MCP server without a local device attached
+    # (e.g., only using cloud_platform parameter in execute_mobile_command).
+    ENABLE_LOCAL_DEVICE: bool = Field(default=True)
 
     # Trajectory GIF download configuration
     # When set, downloads the trajectory GIF after task execution to the specified folder.

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/core/logging_config.py

@@ -13,9 +13,11 @@ def configure_logging(log_level: str = "INFO") -> None:
         log_level: The logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
     """
     # Configure standard library logging
+    # CRITICAL: Use stderr to avoid polluting stdout with non-JSONRPC data
+    # MCP servers communicate via stdio - stdout MUST only contain JSONRPC messages
     logging.basicConfig(
         format="%(message)s",
-        stream=sys.stdout,
+        stream=sys.stderr,
         level=getattr(logging, log_level.upper()),
     )
 

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/core/sdk_agent.py

@@ -3,8 +3,6 @@ import os
 from minitap.mobile_use.sdk import Agent
 from minitap.mobile_use.sdk.builders import Builders
 
-from minitap.mcp.core.config import settings
-
 # Lazy-initialized singleton agent
 _agent: Agent | None = None
 
@@ -26,10 +24,6 @@ def get_mobile_use_agent() -> Agent:
             _, host, port = parts
             config = config.with_adb_server(host=host, port=int(port))
 
-        # Add cloud mobile configuration if set
-        if settings.CLOUD_MOBILE_NAME:
-            config = config.for_cloud_mobile(cloud_mobile_id_or_ref=settings.CLOUD_MOBILE_NAME)
-
         _agent = Agent(config=config.build())
 
     return _agent

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/main.py

@@ -35,7 +35,6 @@ from minitap.mcp.core.logging_config import (
     configure_logging,  # noqa: E402
     get_logger,
 )
-from minitap.mcp.server.cloud_mobile import CloudMobileService
 from minitap.mcp.server.middleware import LocalDeviceHealthMiddleware
 from minitap.mcp.server.poller import device_health_poller
 from minitap.mobile_use.config import settings as sdk_settings
@@ -54,13 +53,7 @@ def main() -> None:
         default=None,
         help="Minitap API key for authentication",
     )
-    parser.add_argument(
-        "--cloud-mobile-name",
-        type=str,
-        required=False,
-        default=None,
-        help="Name of the cloud mobile device to connect to (enables cloud mode)",
-    )
+
     parser.add_argument("--llm-profile", type=str, required=False, default=None)
     parser.add_argument(
         "--server",
@@ -82,11 +75,6 @@ def main() -> None:
         settings.__init__()
         sdk_settings.__init__()
 
-    if args.cloud_mobile_name:
-        os.environ["CLOUD_MOBILE_NAME"] = args.cloud_mobile_name
-        settings.__init__()
-        sdk_settings.__init__()
-
     if args.llm_profile:
         os.environ["MINITAP_LLM_PROFILE_NAME"] = args.llm_profile
         settings.__init__()
@@ -123,7 +111,6 @@ class MCPLifespanContext:
     Stores references to services that need cleanup on shutdown.
     """
 
-    cloud_mobile_service: CloudMobileService | None = None
     local_poller_stop_event: threading.Event | None = None
     local_poller_thread: threading.Thread | None = None
     remote_mcp_proxy: FastMCP | None = None
@@ -133,67 +120,30 @@ class MCPLifespanContext:
 async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
     """Lifespan context manager for MCP server.
 
-    Handles startup/shutdown for both cloud and local modes.
+    Handles startup/shutdown for local and cloud-only modes.
 
-    Cloud mode (CLOUD_MOBILE_NAME set):
-    - Connects to cloud mobile on startup
-    - Maintains keep-alive polling
-    - Disconnects on shutdown (critical for billing!)
-
-    Local mode (CLOUD_MOBILE_NAME not set):
+    Local mode (ENABLE_LOCAL_DEVICE=True, default):
     - Starts device health poller
     - Monitors local device connection
 
+    Cloud-only mode (ENABLE_LOCAL_DEVICE=False):
+    - No local device polling
+    - Use cloud_platform parameter in execute_mobile_command to run tasks
+
     Args:
         server: The FastMCP server instance.
 
     Yields:
         MCPLifespanContext with references to running services.
-
-    Raises:
-        RuntimeError: If cloud mobile connection fails
-            (crashes MCP to prevent false "connected" state).
     """
     from minitap.mcp.core.sdk_agent import get_mobile_use_agent  # noqa: E402
 
     context = MCPLifespanContext()
     api_key = settings.MINITAP_API_KEY.get_secret_value() if settings.MINITAP_API_KEY else None
 
-    # Check if running in cloud mode
-    if settings.CLOUD_MOBILE_NAME:
-        # ==================== CLOUD MODE ====================
-        logger.info(f"Starting MCP in CLOUD mode with mobile: {settings.CLOUD_MOBILE_NAME}")
-
-        if not api_key:
-            logger.error("MINITAP_API_KEY is required")
-            raise RuntimeError(
-                "MINITAP_API_KEY is required when CLOUD_MOBILE_NAME is set. "
-                "Please set your API key via --api-key or MINITAP_API_KEY environment variable."
-            )
-
-        # Create and connect cloud mobile service
-        cloud_service = CloudMobileService(
-            cloud_mobile_name=settings.CLOUD_MOBILE_NAME,
-            api_key=api_key,
-        )
-
-        try:
-            await cloud_service.connect()
-        except Exception as e:
-            # CRITICAL: If cloud mobile not found, crash the MCP!
-            # This prevents the IDE from showing the server as "connected"
-            # when it actually can't do anything useful.
-            logger.error(f"Failed to connect to cloud mobile: {e}")
-            raise RuntimeError(
-                f"Cloud mobile connection failed. The MCP server cannot start.\n{e}"
-            ) from e
-
-        context.cloud_mobile_service = cloud_service
-        logger.info("Cloud mobile connected, MCP server ready")
-
-    else:
+    if settings.ENABLE_LOCAL_DEVICE:
         # ==================== LOCAL MODE ====================
-        logger.info("Starting MCP in LOCAL mode (no CLOUD_MOBILE_NAME set)")
+        logger.info("Starting MCP in LOCAL mode with device polling")
 
         agent = get_mobile_use_agent()
         server.add_middleware(LocalDeviceHealthMiddleware(agent))
@@ -210,6 +160,12 @@ async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
         context.local_poller_stop_event = stop_event
         context.local_poller_thread = poller_thread
         logger.info("Device health poller started")
+    else:
+        # ==================== CLOUD-ONLY MODE ====================
+        logger.info(
+            "Starting MCP without local device polling (ENABLE_LOCAL_DEVICE=False). "
+            "Use cloud_platform parameter in execute_mobile_command to run tasks."
+        )
 
     # ==================== REMOTE MCP PROXY ====================
     # Mount remote MCP proxy if configured (works in both cloud and local modes)
@@ -257,15 +213,6 @@ async def mcp_lifespan(server: FastMCP) -> AsyncIterator[MCPLifespanContext]:
         # ==================== SHUTDOWN ====================
         logger.info("MCP server shutting down, cleaning up resources...")
 
-        if context.cloud_mobile_service:
-            # CRITICAL: Stop cloud mobile connection to stop billing!
-            logger.info("Disconnecting cloud mobile (stopping billing)...")
-            try:
-                await context.cloud_mobile_service.disconnect()
-                logger.info("Cloud mobile disconnected successfully")
-            except Exception as e:
-                logger.error(f"Error disconnecting cloud mobile: {e}")
-
         if context.local_poller_stop_event and context.local_poller_thread:
             # Stop local device health poller
             logger.info("Stopping device health poller...")

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/server/middleware.py

@@ -6,14 +6,18 @@ from minitap.mobile_use.sdk import Agent
 class LocalDeviceHealthMiddleware(Middleware):
     """Middleware that checks local device health before tool calls.
 
-    Only used in local mode (when CLOUD_MOBILE_NAME is not set).
-    For cloud mode, device health is managed by the cloud service.
+    Only used in local mode (when ENABLE_LOCAL_DEVICE is True).
     """
 
     def __init__(self, agent: Agent):
         self.agent = agent
 
     async def on_call_tool(self, context: MiddlewareContext, call_next):
+        # Skip agent check if platform is set (Limrun mode creates its own agent)
+        tool_args = getattr(context.message, "arguments", None) or {}
+        if tool_args.get("cloud_platform"):
+            return await call_next(context)
+
         if not self.agent._initialized:
             raise ToolError(
                 "Agent not initialized.\nMake sure a mobile device is connected and try again."

minitap_mcp-0.9.2/minitap/mcp/tools/execute_mobile_command.py

@@ -0,0 +1,260 @@
+"""Tool for running manual tasks on a connected mobile device."""
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+from mcp.types import TextContent
+from minitap.mobile_use.sdk import Agent
+from minitap.mobile_use.sdk.builders import Builders
+from minitap.mobile_use.sdk.types import LimrunPlatform, ManualTaskConfig
+from minitap.mobile_use.sdk.types.task import PlatformTaskRequest
+from pydantic import Field
+
+from minitap.mcp.core.config import settings
+from minitap.mcp.core.decorators import handle_tool_errors
+from minitap.mcp.core.logging_config import get_logger
+from minitap.mcp.core.sdk_agent import get_mobile_use_agent
+from minitap.mcp.core.storage import StorageDownloadError, download_trajectory_gif
+from minitap.mcp.core.task_runs import TaskRunsError, get_latest_task_run_id
+from minitap.mcp.main import mcp
+
+logger = get_logger(__name__)
+
+
+def _serialize_result(result: Any) -> Any:
+    """Convert SDK responses to serializable data for MCP."""
+    if hasattr(result, "model_dump"):
+        return result.model_dump()
+    if hasattr(result, "dict"):
+        return result.dict()
+    if isinstance(result, Mapping):
+        return dict(result)
+    return result
+
+
+@mcp.tool(
+    name="execute_mobile_command",
+    description="""
+    Execute a natural language command on a mobile device using the Minitap SDK.
+    This tool allows you to control Android or iOS devices using natural language.
+    
+    Set cloud_platform to run on a cloud device (recommended for most use cases).
+    
+    Examples:
+    - execute_mobile_command(cloud_platform="android", goal="Open Settings and check battery level")
+    - execute_mobile_command(cloud_platform="ios", goal="Open Safari and search for weather")
+    
+    App Deployment:
+    You can deploy and test apps by providing the path to a locally built app:
+    - Set app_path to the path of your .apk file (Android) or .app folder (iOS)
+    - The app will be automatically uploaded and installed on the device
+    - Must provide locked_app_package (package name or bundle ID) when using app_path
+    
+    Examples with app deployment:
+    - execute_mobile_command(cloud_platform="android", goal="Test login flow", 
+        app_path="/path/to/app-debug.apk", locked_app_package="com.example.myapp")
+    - execute_mobile_command(cloud_platform="ios", goal="Verify onboarding screens",
+        app_path="/path/to/MyApp.app", locked_app_package="com.example.myapp")
+    """,
+)
+@handle_tool_errors
+async def execute_mobile_command(
+    goal: str = Field(description="High-level goal describing the action to perform."),
+    cloud_platform: LimrunPlatform | None = Field(
+        default=None,
+        description="Cloud platform to run on: 'android' or 'ios'. "
+        "When set, a cloud device is automatically provisioned for this task "
+        "and cleaned up afterwards.",
+    ),
+    output_description: str | None = Field(
+        default=None,
+        description="Optional description of the expected output format. "
+        "For example: 'A JSON array with sender and subject for each email' "
+        "or 'The battery percentage as a number'.",
+    ),
+    locked_app_package: str | None = Field(
+        default=None,
+        description="Optional package name of the app to lock the device to. "
+        "Will launch the app if not already running, and keep it in foreground "
+        "until the task is completed. REQUIRED when using app_path.",
+    ),
+    app_path: str | None = Field(
+        default=None,
+        description="Path to local .apk file (Android) or .app folder (iOS) to deploy. "
+        "The app will be automatically uploaded and installed on the device. "
+        "Must provide locked_app_package when using app_path.",
+    ),
+) -> str | dict[str, Any] | ToolResult:
+    """Run a manual task on a mobile device via the Minitap platform."""
+    try:
+        # Cloud platform mode: provision a cloud device on-demand
+        if cloud_platform:
+            return await _execute_with_cloud_platform(
+                cloud_platform=cloud_platform,
+                goal=goal,
+                output_description=output_description,
+                locked_app_package=locked_app_package,
+                app_path=app_path,
+            )
+
+        # Local device mode
+        if app_path:
+            raise ToolError(
+                "app_path parameter requires cloud_platform to be set. "
+                "App deployment is only supported in cloud platform mode."
+            )
+
+        request = PlatformTaskRequest(
+            task=ManualTaskConfig(
+                goal=goal,
+                output_description=output_description,
+            ),
+            execution_origin="mcp",
+        )
+        agent = get_mobile_use_agent()
+        if not agent._initialized:
+            await agent.init()
+        result = await agent.run_task(
+            request=request,
+            locked_app_package=locked_app_package,
+        )
+
+        trajectory_gif_path: Path | None = None
+        if settings.TRAJECTORY_GIF_DOWNLOAD_FOLDER:
+            trajectory_gif_path = await _download_trajectory_gif_if_available()
+
+        serialized_result = _serialize_result(result)
+
+        # If trajectory was saved, return a ToolResult with multiple content items
+        if trajectory_gif_path:
+            import json
+
+            result_text = (
+                json.dumps(serialized_result, indent=2)
+                if isinstance(serialized_result, dict)
+                else str(serialized_result)
+            )
+            return ToolResult(
+                content=[
+                    TextContent(type="text", text=result_text),
+                    TextContent(type="text", text=f"Trajectory saved to {trajectory_gif_path}"),
+                ],
+            )
+
+        return serialized_result
+    except Exception as e:
+        raise ToolError(str(e))
+
+
+async def _execute_with_cloud_platform(
+    cloud_platform: LimrunPlatform,
+    goal: str,
+    output_description: str | None,
+    locked_app_package: str | None,
+    app_path: str | None = None,
+) -> str | dict[str, Any] | ToolResult:
+    """Execute a task using a cloud device.
+
+    Provisions a cloud device, runs the task, and cleans up afterwards.
+    """
+    api_key = settings.MINITAP_API_KEY.get_secret_value() if settings.MINITAP_API_KEY else None
+    if not api_key:
+        raise ToolError(
+            "MINITAP_API_KEY is required for cloud platform mode. "
+            "Please set your API key via --api-key or MINITAP_API_KEY environment variable."
+        )
+
+    logger.info(f"Provisioning {cloud_platform.value} cloud device for task execution...")
+
+    # Create a dedicated agent for this cloud task
+    config = Builders.AgentConfig.for_limrun(platform=cloud_platform, api_key=api_key)
+    agent = Agent(config=config.build())
+
+    try:
+        await agent.init(api_key=api_key)
+        logger.info(f"{cloud_platform.value} cloud device ready, executing task...")
+
+        request = PlatformTaskRequest(
+            task=ManualTaskConfig(
+                goal=goal,
+                output_description=output_description,
+            ),
+            execution_origin="mcp",
+        )
+
+        # Pass app_path to run_task - SDK handles upload and installation
+        result = await agent.run_task(
+            request=request,
+            locked_app_package=locked_app_package,
+            app_path=app_path,
+        )
+
+        trajectory_gif_path: Path | None = None
+        if settings.TRAJECTORY_GIF_DOWNLOAD_FOLDER:
+            trajectory_gif_path = await _download_trajectory_gif_if_available()
+
+        serialized_result = _serialize_result(result)
+
+        if trajectory_gif_path:
+            import json
+
+            result_text = (
+                json.dumps(serialized_result, indent=2)
+                if isinstance(serialized_result, dict)
+                else str(serialized_result)
+            )
+            return ToolResult(
+                content=[
+                    TextContent(type="text", text=result_text),
+                    TextContent(type="text", text=f"Trajectory saved to {trajectory_gif_path}"),
+                ],
+            )
+
+        return serialized_result
+    finally:
+        # Always clean up the cloud device
+        logger.info(f"Cleaning up {cloud_platform.value} cloud device...")
+        try:
+            await agent.clean()
+            logger.info(f"{cloud_platform.value} cloud device cleaned up successfully")
+        except Exception as e:
+            logger.error(f"Error cleaning up cloud device: {e}")
+
+
+async def _download_trajectory_gif_if_available() -> Path | None:
+    """Download the trajectory GIF if available and folder is configured.
+
+    Fetches the latest task run ID from the API and downloads the GIF.
+
+    Returns:
+        The path to the downloaded GIF file, or None if download failed or not configured.
+    """
+    download_folder = settings.TRAJECTORY_GIF_DOWNLOAD_FOLDER
+    if not download_folder:
+        logger.warning("TRAJECTORY_GIF_DOWNLOAD_FOLDER not configured, skipping GIF download")
+        return None
+
+    task_run_id = None
+    try:
+        task_run_id = await get_latest_task_run_id()
+
+        gif_path = await download_trajectory_gif(
+            task_run_id=task_run_id,
+            download_path=download_folder,
+        )
+        logger.info(
+            "Trajectory GIF downloaded",
+            task_run_id=task_run_id,
+            path=str(gif_path),
+        )
+        return gif_path
+    except (StorageDownloadError, TaskRunsError) as e:
+        logger.warning(
+            "Failed to download trajectory GIF",
+            task_run_id=task_run_id,
+            error=str(e),
+        )
+        return None

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/tools/take_screenshot.py

@@ -1,18 +1,11 @@
 """Simple screenshot capture tool - returns raw base64 image without LLM analysis."""
 
-import base64
-
 from mcp.types import ImageContent
 from pydantic import Field
 
 from minitap.mcp.core.decorators import handle_tool_errors
 from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.main import mcp
-from minitap.mcp.server.cloud_mobile import (
-    check_cloud_mobile_status,
-    get_cloud_mobile_id,
-    get_cloud_screenshot,
-)
 
 
 @mcp.tool(
@@ -32,17 +25,8 @@ async def take_screenshot(
     ),
 ) -> list[ImageContent]:
     """Capture screenshot and return as base64 image content."""
-    cloud_mobile_id = get_cloud_mobile_id()
-
-    if cloud_mobile_id:
-        # Cloud mode: use cloud screenshot API
-        await check_cloud_mobile_status(cloud_mobile_id)
-        screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
-        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
-    else:
-        # Local mode: capture from local device
-        device = find_mobile_device(device_id=device_id)
-        screenshot_base64 = capture_screenshot(device)
+    device = find_mobile_device(device_id=device_id)
+    screenshot_base64 = capture_screenshot(device)
 
     return [
         ImageContent(

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/minitap/mcp/tools/upload_screenshot.py

@@ -5,8 +5,6 @@ to remote storage, returning a filename that can be used with other tools
 like figma_compare_screenshot.
 """
 
-import base64
-
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import ToolResult
 
@@ -15,7 +13,6 @@ from minitap.mcp.core.device import capture_screenshot, find_mobile_device
 from minitap.mcp.core.logging_config import get_logger
 from minitap.mcp.core.storage import StorageUploadError, upload_screenshot_to_storage
 from minitap.mcp.main import mcp
-from minitap.mcp.server.cloud_mobile import get_cloud_mobile_id, get_cloud_screenshot
 
 logger = get_logger(__name__)
 
@@ -26,7 +23,7 @@ logger = get_logger(__name__)
     Capture a screenshot from the connected device and upload it to storage.
     
     This tool:
-    1. Captures a screenshot from the connected device (local or cloud)
+    1. Captures a screenshot from the connected local device
     2. Uploads the screenshot to remote storage
     3. Returns a filename that can be used with other tools
     
@@ -43,23 +40,13 @@ async def upload_screenshot() -> ToolResult:
     """Capture and upload a device screenshot, return the filename."""
     logger.info("Capturing and uploading device screenshot")
 
-    # Step 1: Capture screenshot from device
-    cloud_mobile_id = get_cloud_mobile_id()
-
-    if cloud_mobile_id:
-        logger.debug("Capturing screenshot from cloud device", device_id=cloud_mobile_id)
-        try:
-            screenshot_bytes = await get_cloud_screenshot(cloud_mobile_id)
-            screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
-        except Exception as e:
-            raise ToolError(f"Failed to capture cloud device screenshot: {e}") from e
-    else:
-        logger.debug("Capturing screenshot from local device")
-        try:
-            device = find_mobile_device()
-            screenshot_base64 = capture_screenshot(device)
-        except Exception as e:
-            raise ToolError(f"Failed to capture local device screenshot: {e}") from e
+    # Step 1: Capture screenshot from local device
+    logger.debug("Capturing screenshot from local device")
+    try:
+        device = find_mobile_device()
+        screenshot_base64 = capture_screenshot(device)
+    except Exception as e:
+        raise ToolError(f"Failed to capture local device screenshot: {e}") from e
 
     logger.info("Screenshot captured from device")
 

{minitap_mcp-0.9.0 → minitap_mcp-0.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitap-mcp"
-version = "0.9.0"
+version = "0.9.2"
 description = "Model Context Protocol server for controlling Android & iOS devices with natural language"
 readme = "PYPI_README.md"
 
@@ -17,7 +17,7 @@ dependencies = [
     "python-dotenv>=1.1.1",
     "pydantic>=2.12.0",
     "pydantic-settings>=2.10.1",
-    "minitap-mobile-use>=3.4.0",
+    "minitap-mobile-use>=3.5.0",
     "jinja2>=3.1.6",
     "langchain-core>=0.3.75",
     "pillow>=11.1.0",