minitap-mcp 0.1.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

minitap/mcp/tools/compare_screenshot_with_figma.py

@@ -0,0 +1,132 @@
+"""Tool for navigating to a screen and comparing it with Figma design."""
+
+import base64
+from io import BytesIO
+
+import mcp as mcp_ref
+from fastmcp import Client
+from fastmcp.client.client import CallToolResult
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+from PIL import Image
+from pydantic import Field
+
+from minitap.mcp.core.agents.compare_screenshots import compare_screenshots
+from minitap.mcp.core.config import settings
+from minitap.mcp.core.decorators import handle_tool_errors
+from minitap.mcp.main import mcp
+
+
+@mcp.tool(
+    name="compare_screenshot_with_figma",
+    description="""
+    Compare a screenshot of the current state with a Figma design.
+    
+    This tool:
+    1. Captures a screenshot of the current state
+    2. Compares the live device screenshot with the Figma design
+    3. Returns a detailed comparison report with both screenshots for visual context
+    """,
+)
+@handle_tool_errors
+async def compare_screenshot_with_figma(
+    node_id: str = Field(
+        description=(
+            "The node ID of the Figma design. Expected format is ':' separated.\n"
+            "Example: If given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2,\n"
+            "the extracted nodeId would be 1:2. Strictly respect this format."
+        )
+    ),
+) -> ToolResult:
+    expected_screenshot_base64 = await get_figma_screenshot(node_id)
+
+    result = await compare_screenshots(
+        expected_screenshot_base64=expected_screenshot_base64,
+    )
+
+    compressed_expected = compress_image_base64(result.expected_screenshot_base64)
+    compressed_current = compress_image_base64(result.current_screenshot_base64)
+
+    return ToolResult(
+        content=[
+            mcp_ref.types.TextContent(
+                type="text",
+                text="## Comparison Analysis\n\n" + str(result.comparison_text),
+            ),
+            mcp_ref.types.ImageContent(
+                type="image",
+                data=compressed_expected,
+                mimeType="image/jpeg",
+            ),
+            mcp_ref.types.TextContent(
+                type="text",
+                text="**Expected (Figma design)** ↑\n\n**Actual (Current device)** ↓",
+            ),
+            mcp_ref.types.ImageContent(
+                type="image",
+                data=compressed_current,
+                mimeType="image/jpeg",
+            ),
+        ]
+    )
+
+
+def compress_image_base64(base64_str: str, max_width: int = 800, quality: int = 75) -> str:
+    """Compress and resize a base64-encoded image to reduce size.
+
+    Args:
+        base64_str: Base64-encoded image string
+        max_width: Maximum width for the resized image
+        quality: JPEG quality (1-95, lower = smaller file)
+
+    Returns:
+        Compressed base64-encoded image string
+    """
+    try:
+        img_data = base64.b64decode(base64_str)
+        img = Image.open(BytesIO(img_data))
+
+        if img.mode in ("RGBA", "P", "LA"):
+            background = Image.new("RGB", img.size, (255, 255, 255))
+            if img.mode == "P":
+                img = img.convert("RGBA")
+            if "A" in img.mode:
+                background.paste(img, mask=img.split()[-1])
+            else:
+                background.paste(img)
+            img = background
+        elif img.mode != "RGB":
+            img = img.convert("RGB")
+
+        if img.width > max_width:
+            ratio = max_width / img.width
+            new_height = int(img.height * ratio)
+            img = img.resize((max_width, new_height), Image.Resampling.LANCZOS)
+
+        buffer = BytesIO()
+        img.save(buffer, format="JPEG", quality=quality, optimize=True)
+        compressed_data = buffer.getvalue()
+
+        return base64.b64encode(compressed_data).decode("utf-8")
+    except Exception:
+        return base64_str
+
+
+async def get_figma_screenshot(node_id: str) -> str:
+    try:
+        async with Client(settings.FIGMA_MCP_SERVER_URL) as client:
+            result: CallToolResult = await client.call_tool(
+                "get_screenshot",
+                {
+                    "nodeId": node_id,
+                    "clientLanguages": "javascript",
+                    "clientFrameworks": "react",
+                },
+            )
+            if len(result.content) == 0 or not isinstance(
+                result.content[0], mcp_ref.types.ImageContent
+            ):
+                raise ToolError("Failed to fetch screenshot from Figma")
+        return result.content[0].data
+    except Exception as e:
+        raise ToolError(f"Failed to fetch screenshot from Figma: {str(e)}")

minitap/mcp/tools/execute_mobile_command.py

@@ -3,12 +3,13 @@
 from collections.abc import Mapping
 from typing import Any
 
+from fastmcp.exceptions import ToolError
 from minitap.mobile_use.sdk.types import ManualTaskConfig
 from minitap.mobile_use.sdk.types.task import PlatformTaskRequest
 from pydantic import Field
 
-from minitap.mcp.core.agents import agent
 from minitap.mcp.core.decorators import handle_tool_errors
+from minitap.mcp.core.sdk_agent import get_mobile_use_agent
 from minitap.mcp.main import mcp
 
 
@@ -58,7 +59,8 @@ async def execute_mobile_command(
         request = PlatformTaskRequest(
             task=ManualTaskConfig(goal=goal, output_description=output_description),
         )
+        agent = get_mobile_use_agent()
         result = await agent.run_task(request=request)
         return _serialize_result(result)
-    finally:
-        agent.clean()
+    except Exception as e:
+        raise ToolError(str(e))

minitap/mcp/tools/save_figma_assets.py

@@ -0,0 +1,258 @@
+"""Tool for fetching and saving Figma assets locally."""
+
+import shutil
+from pathlib import Path
+
+import mcp as mcp_ref
+import requests
+from fastmcp import Client
+from fastmcp.client.client import CallToolResult
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.tool import ToolResult
+from pydantic import Field
+
+from minitap.mcp.core.agents.extract_figma_assets import (
+    ExtractedAssets,
+    FigmaAsset,
+    extract_figma_assets,
+)
+from minitap.mcp.core.config import settings
+from minitap.mcp.core.decorators import handle_tool_errors
+from minitap.mcp.core.models import (
+    AssetDownloadResult,
+    AssetDownloadSummary,
+    DownloadStatus,
+    FigmaDesignContextOutput,
+)
+from minitap.mcp.main import mcp
+from minitap.mcp.tools.compare_screenshot_with_figma import (
+    compress_image_base64,
+    get_figma_screenshot,
+)
+
+
+@mcp.tool(
+    name="save_figma_assets",
+    description="""
+    Fetch Figma design assets/react implementation code and save them locally in the workspace.
+    
+    This tool:
+    1. Calls get_design_context from Figma MCP to get the React/TypeScript code
+    2. Extracts all asset URLs and code implementation from the code
+    3. Downloads each asset to .mobile-use/figma_assets/<node-id>/ folder
+    4. Saves the code implementation to .mobile-use/figma_assets/<node-id>/code_implementation.ts
+    5. Returns a list of downloaded files
+    """,
+)
+@handle_tool_errors
+async def save_figma_assets(
+    node_id: str = Field(
+        description=(
+            "The node ID of the Figma design. Expected format is ':' separated.\n"
+            "Example: If given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2,\n"
+            "the extracted nodeId would be 1:2. Strictly respect this format."
+        )
+    ),
+    file_key: str = Field(
+        description=(
+            "The file key of the Figma file.\n"
+            "Example: If given the URL https://figma.com/design/abc123/MyFile?node-id=1-2,\n"
+            "the extracted fileKey would be 'abc123'."
+        )
+    ),
+    workspace_path: str = Field(
+        default=".",
+        description=(
+            "The workspace path where assets should be saved. Defaults to current directory."
+        ),
+    ),
+) -> ToolResult:
+    """Fetch and save Figma assets locally."""
+
+    # Step 1: Get design context from Figma MCP
+    design_context = await get_design_context(node_id, file_key)
+
+    # Step 2: Extract asset URLs using LLM agent
+    extracted_context: ExtractedAssets = await extract_figma_assets(
+        design_context.code_implementation
+    )
+    if not extracted_context.assets:
+        raise ToolError("No assets found in the Figma design context.")
+
+    # Step 3: Create directory structure
+    # Convert node_id format (1:2) to folder name (1-2)
+    folder_name = node_id.replace(":", "-")
+    assets_dir = Path(workspace_path) / ".mobile-use" / "figma_assets" / folder_name
+
+    # Delete existing directory to remove stale assets
+    if assets_dir.exists():
+        shutil.rmtree(assets_dir)
+
+    # Create fresh directory
+    assets_dir.mkdir(parents=True, exist_ok=True)
+
+    # Step 4: Download assets with resilient error handling
+    download_summary = AssetDownloadSummary()
+
+    for asset in extracted_context.assets:
+        result = download_asset(asset, assets_dir)
+        if result.status == DownloadStatus.SUCCESS:
+            download_summary.successful.append(result)
+        else:
+            download_summary.failed.append(result)
+
+    # Step 4.5: Save code implementation
+    code_implementation_file = assets_dir / "code_implementation.ts"
+
+    commented_code_implementation_guidelines = ""
+    if design_context.code_implementation_guidelines:
+        commented_code_implementation_guidelines = "\n".join(
+            ["// " + line for line in design_context.code_implementation_guidelines.split("\n")]
+        )
+
+    commented_nodes_guidelines = ""
+    if design_context.nodes_guidelines:
+        commented_nodes_guidelines = "\n".join(
+            ["// " + line for line in design_context.nodes_guidelines.split("\n")]
+        )
+
+    code_implementation_file.write_text(
+        extracted_context.code_implementation
+        + "\n\n"
+        + commented_code_implementation_guidelines
+        + "\n\n"
+        + commented_nodes_guidelines
+    )
+
+    # Step 5: Generate friendly output message
+    result_parts = []
+
+    if download_summary.successful:
+        result_parts.append(
+            f"✅ Successfully downloaded {download_summary.success_count()} asset(s) "
+            f"to .mobile-use/figma_assets/{folder_name}/:\n"
+        )
+        for asset_result in download_summary.successful:
+            result_parts.append(f"  • {asset_result.filename}")
+
+    if download_summary.failed:
+        result_parts.append(
+            f"\n\n⚠️ Failed to download {download_summary.failure_count()} asset(s):"
+        )
+        for asset_result in download_summary.failed:
+            error_msg = f": {asset_result.error}" if asset_result.error else ""
+            result_parts.append(f"  • {asset_result.filename}{error_msg}")
+
+    if code_implementation_file.exists():
+        result_parts.append(
+            f"\n\n✅ Successfully saved code implementation to {code_implementation_file.name}"
+        )
+
+    expected_screenshot = await get_figma_screenshot(node_id)
+    compressed_expected = compress_image_base64(expected_screenshot)
+
+    return ToolResult(
+        content=[
+            mcp_ref.types.TextContent(
+                type="text",
+                text="\n".join(result_parts),
+            ),
+            mcp_ref.types.TextContent(
+                type="text",
+                text="**Expected (Figma design)**",
+            ),
+            mcp_ref.types.ImageContent(
+                type="image",
+                data=compressed_expected,
+                mimeType="image/jpeg",
+            ),
+        ]
+    )
+
+
+async def get_design_context(node_id: str, file_key: str) -> FigmaDesignContextOutput:
+    """Fetch design context from Figma MCP server.
+
+    Args:
+        node_id: The Figma node ID in format "1:2"
+        file_key: The Figma file key
+
+    Returns:
+        The React/TypeScript code as a string
+
+    Raises:
+        ToolError: If fetching fails
+    """
+    try:
+        async with Client(settings.FIGMA_MCP_SERVER_URL) as client:
+            result: CallToolResult = await client.call_tool(
+                "get_design_context",
+                {
+                    "nodeId": node_id,
+                    "fileKey": file_key,
+                    "clientLanguages": "typescript",
+                    "clientFrameworks": "react",
+                },
+            )
+
+            code_implementation = ""
+            code_implementation_guidelines = None
+            nodes_guidelines = None
+
+            if len(result.content) > 0 and isinstance(result.content[0], mcp_ref.types.TextContent):
+                code_implementation = result.content[0].text
+            else:
+                raise ToolError("Failed to fetch design context from Figma")
+
+            if len(result.content) > 1:
+                if isinstance(result.content[1], mcp_ref.types.TextContent):
+                    code_implementation_guidelines = result.content[1].text
+            if len(result.content) > 2 and isinstance(result.content[2], mcp_ref.types.TextContent):
+                nodes_guidelines = result.content[2].text
+
+            return FigmaDesignContextOutput(
+                code_implementation=code_implementation,
+                code_implementation_guidelines=code_implementation_guidelines,
+                nodes_guidelines=nodes_guidelines,
+            )
+    except Exception as e:
+        raise ToolError(
+            f"Failed to fetch design context from Figma: {str(e)}.\n"
+            "Ensure the Figma MCP server is running through the official Figma desktop app."
+        )
+
+
+def download_asset(asset: FigmaAsset, assets_dir: Path) -> AssetDownloadResult:
+    """Download a single asset with error handling.
+
+    Args:
+        asset: FigmaAsset model with variable_name, url, and extension
+        assets_dir: Directory to save the asset
+
+    Returns:
+        AssetDownloadResult with status and optional error message
+    """
+    variable_name = asset.variable_name
+    url = asset.url
+    extension = asset.extension
+
+    # Convert camelCase variable name to filename
+    # e.g., imgSignal -> imgSignal.svg
+    filename = f"{variable_name}.{extension}"
+    filepath = assets_dir / filename
+
+    try:
+        response = requests.get(url, timeout=30)
+        if response.status_code == 200:
+            filepath.write_bytes(response.content)
+            return AssetDownloadResult(filename=filename, status=DownloadStatus.SUCCESS)
+        else:
+            return AssetDownloadResult(
+                filename=filename,
+                status=DownloadStatus.FAILED,
+                error=f"HTTP {response.status_code}",
+            )
+    except requests.exceptions.Timeout:
+        return AssetDownloadResult(filename=filename, status=DownloadStatus.FAILED, error="Timeout")
+    except Exception as e:
+        return AssetDownloadResult(filename=filename, status=DownloadStatus.FAILED, error=str(e))

minitap_mcp-0.4.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.3
+Name: minitap-mcp
+Version: 0.4.0
+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>=2.8.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: langchain-core>=0.3.75
+Requires-Dist: pillow>=11.1.0
+Requires-Dist: ruff==0.5.3 ; extra == 'dev'
+Requires-Dist: pytest==8.4.1 ; extra == 'dev'
+Requires-Dist: pytest-cov==5.0.0 ; extra == 'dev'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://minitap.ai/
+Project-URL: Source, https://github.com/minitap-ai/mobile-use
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# Minitap MCP Server
+
+A Model Context Protocol (MCP) server that enables AI assistants to control and interact with real mobile devices (Android & iOS) through natural language commands.
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install minitap-mcp
+```
+
+### Prerequisites
+
+Before running the MCP server, ensure you have the required mobile automation tools installed:
+
+- **For Android devices:**
+  - [ADB (Android Debug Bridge)](https://developer.android.com/tools/adb) - For device communication
+  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
+
+- **For iOS devices (macOS only):**
+  - Xcode Command Line Tools with `xcrun`
+  - [Maestro](https://maestro.mobile.dev/) - For mobile automation
+
+For detailed setup instructions, see the [mobile-use repository](https://github.com/minitap-ai/mobile-use).
+
+### Running the Server
+
+The simplest way to start:
+
+```bash
+minitap-mcp --server --api-key your_minitap_api_key
+```
+
+This starts the server on `localhost:8000` with your API key. Get your free API key at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
+
+**Available CLI options:**
+
+```bash
+minitap-mcp --server --api-key YOUR_KEY --llm-profile PROFILE_NAME
+```
+
+- `--api-key`: Your Minitap API key (overrides `MINITAP_API_KEY` env var). Get yours at [platform.minitap.ai/api-keys](https://platform.minitap.ai/api-keys).
+- `--llm-profile`: LLM profile name to use (overrides `MINITAP_LLM_PROFILE_NAME` env var). If unset, uses the default profile. Configure profiles at [platform.minitap.ai/llm-profiles](https://platform.minitap.ai/llm-profiles).
+
+### Configuration (Optional)
+
+Alternatively, you can set environment variables instead of using CLI flags:
+
+```bash
+export MINITAP_API_KEY="your_minitap_api_key"
+export MINITAP_API_BASE_URL="https://platform.minitap.ai/api/v1"
+export MINITAP_LLM_PROFILE_NAME="default"
+```
+
+You can set these in your `.bashrc` or equivalent, then simply run:
+
+```bash
+minitap-mcp --server
+```
+
+CLI flags always override environment variables when both are present.
+
+By default, the server will bind to `0.0.0.0:8000`. Configure via environment variables:
+
+```bash
+export MCP_SERVER_HOST="0.0.0.0"
+export MCP_SERVER_PORT="8000"
+```
+
+## IDE Integration
+
+1. Start the server: `minitap-mcp --server --api-key your_minitap_api_key`
+2. Add to your IDE MCP settings file:
+
+```jsonc
+# For Windsurf
+{
+  "mcpServers": {
+    "minitap-mcp": {
+      "serverUrl": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+```jsonc
+# For Cursor
+{
+  "mcpServers": {
+    "minitap-mcp": {
+      "transport": "http",
+      "url": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+
+## Available Tools
+
+Once connected, your AI assistant can use these tools:
+
+### `execute_mobile_command`
+Execute natural language commands on your mobile device using the Minitap SDK. This tool allows you to control your Android or iOS device using natural language.
+
+**Parameters:**
+- `goal` (required): High-level goal describing the action to perform
+- `output_description` (optional): Natural language description of the desired output format. Results are returned as structured JSON (e.g., "An array with sender and subject for each email")
+- `profile` (optional): Profile name to use (defaults to "default")
+
+**Examples:**
+```
+"Open the settings app and tell me the battery level"
+"Find the first 3 unread emails in Gmail"
+"Open Google Maps and search for the nearest coffee shop"
+"Take a screenshot and save it"
+```
+
+### `analyze_screen`
+Capture and analyze what's currently shown on the mobile device screen using a vision-capable LLM. Useful for understanding UI elements, extracting text, or identifying specific features.
+
+**Parameters:**
+- `prompt` (required): Analysis prompt describing what information to extract
+- `device_id` (optional): Specific device ID to target
+
+**Examples:**
+```js
+"What app is currently open?"
+"Read the text messages visible on screen"
+"List all buttons and their labels on the current screen"
+"Extract the phone number displayed"
+```
+
+## Advanced Configuration
+
+### Custom ADB Server
+
+If using a remote or custom ADB server (like on WSL):
+
+```bash
+export ADB_SERVER_SOCKET="tcp:192.168.1.100:5037"
+```
+
+### Vision Model
+
+Customize the vision model used for screen analysis:
+
+```bash
+export VISION_MODEL="qwen/qwen-2.5-vl-7b-instruct"
+```
+
+## Device Setup
+
+### Android
+1. Enable USB debugging on your device
+2. Connect via USB or network ADB
+3. Verify connection: `adb devices`
+
+### iOS (macOS only)
+1. Install Xcode Command Line Tools
+2. Start a simulator or connect a physical device
+3. Verify: `xcrun simctl list devices booted`
+
+## Troubleshooting
+
+**No devices found:**
+- Verify ADB/xcrun connection
+- Check USB debugging is enabled (Android)
+- Ensure device is unlocked
+
+**Connection refused errors:**
+- Check ADB/xcrun connection
+
+**API authentication errors:**
+- Verify `MINITAP_API_KEY` is set correctly
+
+## Links
+
+- **Mobile-Use SDK:** [github.com/minitap-ai/mobile-use](https://github.com/minitap-ai/mobile-use)
+- **Mobile-Use Documentation:** [docs.minitap.ai](https://docs.minitap.ai)

minitap_mcp-0.4.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+minitap/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minitap/mcp/core/agents/compare_screenshots.md,sha256=Gt27HVzXzu71BxcanKPokz1dFPvq90vXbjE2HOn5X0I,3559
+minitap/mcp/core/agents/compare_screenshots.py,sha256=Yb7kR8Cv0gWzXyNf-6IS7_9l1npfqYmL-SONJJGgzM4,2060
+minitap/mcp/core/agents/extract_figma_assets.md,sha256=JrXuWF8-2PeQpVix-kf-p6zmu2gQVf9Z6ptTK1cedDk,2413
+minitap/mcp/core/agents/extract_figma_assets.py,sha256=WAmn4CvN1ONJkJp2KH9l080hhZ_ge0Pdan6ejk_GWOo,2038
+minitap/mcp/core/config.py,sha256=gfx-cXJsgB_W2dSNHnb5jeWEYfe3VBZUMeF1nbNAdiQ,962
+minitap/mcp/core/decorators.py,sha256=iekv181o_rkv0upacFWkmPqxsZRTzuLFyOZ0sIDtQnQ,1317
+minitap/mcp/core/device.py,sha256=sEO3Z-8F325hDOObdH1YBhZE60f17FmIclt5UlhY_nU,7875
+minitap/mcp/core/llm.py,sha256=z_pYZkZcAchsiWPh4W79frQPANsfYyFPUe8DJo8lZO0,822
+minitap/mcp/core/models.py,sha256=egLScxPAMo4u5cqY33UKba7z7DsdgqfPW409UAqW1Jg,1942
+minitap/mcp/core/sdk_agent.py,sha256=-9l1YetD93dzxOeSFOT_j8dDfDFjhJLiir8bhzEjI3Y,900
+minitap/mcp/core/utils.py,sha256=3uExpRoh7affIieZx3TLlZTmZCcoxWfx1YpPbwhjiJY,1791
+minitap/mcp/main.py,sha256=B7KE6_5UNGKanS0WMJYBq8vp0HE_Lr0BG9KR4BwYxwU,4341
+minitap/mcp/server/middleware.py,sha256=fbry_IiHmwUxVjsWgOU2goybcS1kLRXFZZ89KPH1d8E,880
+minitap/mcp/server/poller.py,sha256=Qakq4yO3EJ9dXmRqtE3sJjyk0ij7VBU-NuupHhTf37g,2539
+minitap/mcp/tools/analyze_screen.py,sha256=fjcjf3tTZDlxzmiQFHFNgw38bxPz4eisw57zuxshN2A,1984
+minitap/mcp/tools/compare_screenshot_with_figma.py,sha256=G69F6vRFI2tE2wW-oFYPjnY8oFMD9nRZH0H-yvtD4gE,4575
+minitap/mcp/tools/execute_mobile_command.py,sha256=qY3UfcDq1BtYcny1YlEF4WV9LwUJxLAmLJCm1VBzxS8,2442
+minitap/mcp/tools/go_back.py,sha256=lEmADkDkXu8JGm-sY7zL7M6GlBy-lD7Iffv4yzwoQfo,1301
+minitap/mcp/tools/save_figma_assets.py,sha256=EN0u0TkCUXoz8guehxm-CywKYYmZFg_d4x35eTNAovQ,9182
+minitap/mcp/tools/screen_analyzer.md,sha256=TTO80JQWusbA9cKAZn-9cqhgVHm6F_qJh5w152hG3YM,734
+minitap_mcp-0.4.0.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
+minitap_mcp-0.4.0.dist-info/entry_points.txt,sha256=rYVoXm7tSQCqQTtHx4Lovgn1YsjwtEEHfddKrfEVHuY,55
+minitap_mcp-0.4.0.dist-info/METADATA,sha256=27wi_Bedtm971es6fHljAF8wE45uCkSoYYwwqqFvmY0,5885
+minitap_mcp-0.4.0.dist-info/RECORD,,

{minitap_mcp-0.1.1.dist-info → minitap_mcp-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.2
+Generator: uv 0.9.7
 Root-Is-Purelib: true
 Tag: py3-none-any

minitap/mcp/core/agents.py

@@ -1,19 +0,0 @@
-import os
-
-from minitap.mobile_use.sdk import Agent
-from minitap.mobile_use.sdk.builders import Builders
-
-
-def get_mobile_use_agent():
-    config = Builders.AgentConfig
-    custom_adb_socket = os.getenv("ADB_SERVER_SOCKET")
-    if custom_adb_socket:
-        parts = custom_adb_socket.split(":")
-        if len(parts) != 3:
-            raise ValueError(f"Invalid ADB server socket: {custom_adb_socket}")
-        _, host, port = parts
-        config = config.with_adb_server(host=host, port=int(port))
-    return Agent(config=config.build())
-
-
-agent = get_mobile_use_agent()