coplay-mcp-server 1.4.1__py3-none-any.whl

coplay_mcp_server/generated_tools/package_tool_tools.py

@@ -0,0 +1,240 @@
+"""Generated MCP tools from package_tool_schema.json"""
+
+import logging
+from typing import Annotated, Optional, Any, Dict, Literal
+from pydantic import Field
+from fastmcp import FastMCP
+from ..unity_client import UnityRpcClient
+
+logger = logging.getLogger(__name__)
+
+# Global references to be set by register_tools
+_mcp: Optional[FastMCP] = None
+_unity_client: Optional[UnityRpcClient] = None
+
+
+async def export_package(
+    asset_paths: Annotated[
+        str,
+        Field(
+            description="""Comma-separated list of asset paths to include."""
+        ),
+    ],
+    package_name: Annotated[
+        str,
+        Field(
+            description="""Name of the package file."""
+        ),
+    ],
+) -> Any:
+    """Exports selected assets as a Unity package."""
+    try:
+        logger.debug(f"Executing export_package with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if asset_paths is not None:
+            params['asset_paths'] = str(asset_paths)
+        if package_name is not None:
+            params['package_name'] = str(package_name)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('export_package', params)
+        logger.debug(f"export_package completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute export_package: {e}")
+        raise RuntimeError(f"Tool execution failed for export_package: {e}")
+
+
+async def install_unity_package(
+    package_name: Annotated[
+        str,
+        Field(
+            description="""The name of the Unity package to install."""
+        ),
+    ],
+    version: Annotated[
+        str | None,
+        Field(
+            description="""Optional version of the package. If not specified, the latest version will be installed."""
+        ),
+    ] = None,
+) -> Any:
+    """Installs a Unity package by name and optional version."""
+    try:
+        logger.debug(f"Executing install_unity_package with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if package_name is not None:
+            params['package_name'] = str(package_name)
+        if version is not None:
+            params['version'] = str(version)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('install_unity_package', params)
+        logger.debug(f"install_unity_package completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute install_unity_package: {e}")
+        raise RuntimeError(f"Tool execution failed for install_unity_package: {e}")
+
+
+async def install_git_package(
+    repository_url: Annotated[
+        str,
+        Field(
+            description="""The URL of the public Git repository containing the Unity package."""
+        ),
+    ],
+    branch: Annotated[
+        str | None,
+        Field(
+            description="""Optional branch to use. Defaults to the main or master branch."""
+        ),
+    ] = None,
+    package_name: Annotated[
+        str | None,
+        Field(
+            description="""Optional name for the package."""
+        ),
+    ] = None,
+) -> Any:
+    """Installs a Unity package from a public Git repository."""
+    try:
+        logger.debug(f"Executing install_git_package with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if repository_url is not None:
+            params['repository_url'] = str(repository_url)
+        if branch is not None:
+            params['branch'] = str(branch)
+        if package_name is not None:
+            params['package_name'] = str(package_name)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('install_git_package', params)
+        logger.debug(f"install_git_package completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute install_git_package: {e}")
+        raise RuntimeError(f"Tool execution failed for install_git_package: {e}")
+
+
+async def remove_unity_package(
+    package_name: Annotated[
+        str,
+        Field(
+            description="""The name of the Unity package to remove."""
+        ),
+    ],
+) -> Any:
+    """Removes a Unity package by its name."""
+    try:
+        logger.debug(f"Executing remove_unity_package with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if package_name is not None:
+            params['package_name'] = str(package_name)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('remove_unity_package', params)
+        logger.debug(f"remove_unity_package completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute remove_unity_package: {e}")
+        raise RuntimeError(f"Tool execution failed for remove_unity_package: {e}")
+
+
+async def list_packages(
+) -> Any:
+    """Retrieves a list of installed packages in this project."""
+    try:
+        logger.debug(f"Executing list_packages with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('list_packages', params)
+        logger.debug(f"list_packages completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute list_packages: {e}")
+        raise RuntimeError(f"Tool execution failed for list_packages: {e}")
+
+
+async def search_installed_packages(
+    package_name: Annotated[
+        str,
+        Field(
+            description="""The name of the package to search for."""
+        ),
+    ],
+) -> Any:
+    """Searches for installed packages in this project."""
+    try:
+        logger.debug(f"Executing search_installed_packages with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if package_name is not None:
+            params['package_name'] = str(package_name)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('search_installed_packages', params)
+        logger.debug(f"search_installed_packages completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute search_installed_packages: {e}")
+        raise RuntimeError(f"Tool execution failed for search_installed_packages: {e}")
+
+
+async def search_all_packages(
+) -> Any:
+    """Searches for packages in the Unity registry."""
+    try:
+        logger.debug(f"Executing search_all_packages with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('search_all_packages', params)
+        logger.debug(f"search_all_packages completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute search_all_packages: {e}")
+        raise RuntimeError(f"Tool execution failed for search_all_packages: {e}")
+
+
+def register_tools(mcp: FastMCP, unity_client: UnityRpcClient) -> None:
+    """Register all tools from package_tool_schema with the MCP server."""
+    global _mcp, _unity_client
+    _mcp = mcp
+    _unity_client = unity_client
+
+    # Register export_package
+    mcp.tool()(export_package)
+    # Register install_unity_package
+    mcp.tool()(install_unity_package)
+    # Register install_git_package
+    mcp.tool()(install_git_package)
+    # Register remove_unity_package
+    mcp.tool()(remove_unity_package)
+    # Register list_packages
+    mcp.tool()(list_packages)
+    # Register search_installed_packages
+    mcp.tool()(search_installed_packages)
+    # Register search_all_packages
+    mcp.tool()(search_all_packages)

coplay_mcp_server/generated_tools/profiler_functions_tools.py

@@ -0,0 +1,63 @@
+"""Generated MCP tools from profiler_functions_schema.json"""
+
+import logging
+from typing import Annotated, Optional, Any, Dict, Literal
+from pydantic import Field
+from fastmcp import FastMCP
+from ..unity_client import UnityRpcClient
+
+logger = logging.getLogger(__name__)
+
+# Global references to be set by register_tools
+_mcp: Optional[FastMCP] = None
+_unity_client: Optional[UnityRpcClient] = None
+
+
+async def get_worst_cpu_frames(
+) -> Any:
+    """Identifies the worst CPU frames in profiling data, formats their function calls and timings, and returns the result as a string."""
+    try:
+        logger.debug(f"Executing get_worst_cpu_frames with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('get_worst_cpu_frames', params)
+        logger.debug(f"get_worst_cpu_frames completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute get_worst_cpu_frames: {e}")
+        raise RuntimeError(f"Tool execution failed for get_worst_cpu_frames: {e}")
+
+
+async def get_worst_gc_frames(
+) -> Any:
+    """Identifies the worst GC frames in profiling data, formats their function calls and allocation sizes, and returns the result as a string."""
+    try:
+        logger.debug(f"Executing get_worst_gc_frames with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('get_worst_gc_frames', params)
+        logger.debug(f"get_worst_gc_frames completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute get_worst_gc_frames: {e}")
+        raise RuntimeError(f"Tool execution failed for get_worst_gc_frames: {e}")
+
+
+def register_tools(mcp: FastMCP, unity_client: UnityRpcClient) -> None:
+    """Register all tools from profiler_functions_schema with the MCP server."""
+    global _mcp, _unity_client
+    _mcp = mcp
+    _unity_client = unity_client
+
+    # Register get_worst_cpu_frames
+    mcp.tool()(get_worst_cpu_frames)
+    # Register get_worst_gc_frames
+    mcp.tool()(get_worst_gc_frames)

coplay_mcp_server/generated_tools/scene_view_functions_tools.py

@@ -0,0 +1,58 @@
+"""Generated MCP tools from scene_view_functions_schema.json"""
+
+import logging
+from typing import Annotated, Optional, Any, Dict, Literal
+from pydantic import Field
+from fastmcp import FastMCP
+from ..unity_client import UnityRpcClient
+
+logger = logging.getLogger(__name__)
+
+# Global references to be set by register_tools
+_mcp: Optional[FastMCP] = None
+_unity_client: Optional[UnityRpcClient] = None
+
+
+async def scene_view_functions(
+    toggle_2d_mode: Annotated[
+        bool | None,
+        Field(
+            description="""Toggle between 2D and 3D Scene View mode. Set to true for 2D mode, false for 3D mode, or null to leave unchanged."""
+        ),
+    ] = None,
+    toggle_lighting: Annotated[
+        bool | None,
+        Field(
+            description="""Toggle Scene View lighting on/off. When enabled, shows realistic lighting in the Scene View. Set to true to enable, false to disable, or null to leave unchanged."""
+        ),
+    ] = None,
+) -> Any:
+    """Control Unity Scene View settings including 2D/3D mode, lighting."""
+    try:
+        logger.debug(f"Executing scene_view_functions with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if toggle_2d_mode is not None:
+            params['toggle_2d_mode'] = str(toggle_2d_mode)
+        if toggle_lighting is not None:
+            params['toggle_lighting'] = str(toggle_lighting)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('scene_view_functions', params)
+        logger.debug(f"scene_view_functions completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute scene_view_functions: {e}")
+        raise RuntimeError(f"Tool execution failed for scene_view_functions: {e}")
+
+
+def register_tools(mcp: FastMCP, unity_client: UnityRpcClient) -> None:
+    """Register all tools from scene_view_functions_schema with the MCP server."""
+    global _mcp, _unity_client
+    _mcp = mcp
+    _unity_client = unity_client
+
+    # Register scene_view_functions
+    mcp.tool()(scene_view_functions)

coplay_mcp_server/generated_tools/screenshot_tool_tools.py

@@ -0,0 +1,87 @@
+"""Generated MCP tools from screenshot_tool_schema.json"""
+
+import logging
+from typing import Annotated, Optional, Any, Dict, Literal
+from pydantic import Field
+from fastmcp import FastMCP
+from ..unity_client import UnityRpcClient
+
+logger = logging.getLogger(__name__)
+
+# Global references to be set by register_tools
+_mcp: Optional[FastMCP] = None
+_unity_client: Optional[UnityRpcClient] = None
+
+
+async def get_scene_view_screenshot(
+    gameObjectPath: Annotated[
+        str | None,
+        Field(
+            description="""Optional path of a game object in the active hierarchy to focus on before taking the screenshot (e.g. '/Root/Parent/Child'). If provided, the scene view will be focused on this object. If empty or null, no focusing will be performed."""
+        ),
+    ] = None,
+    includeUI: Annotated[
+        bool | None,
+        Field(
+            description="""Optional flag to include UI elements (gizmos, handles, overlays) in the screenshot. Defaults to false if not specified. When false, only the camera view is captured without UI elements."""
+        ),
+    ] = None,
+) -> Any:
+    """Captures a screenshot of the current Scene view. Use this tool to inspect or analyze the visual appearance of objects after making visual changes to a scene or prefab. Do not use it for validating UI Canvases."""
+    try:
+        logger.debug(f"Executing get_scene_view_screenshot with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if gameObjectPath is not None:
+            params['gameObjectPath'] = str(gameObjectPath)
+        if includeUI is not None:
+            params['includeUI'] = str(includeUI)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('get_scene_view_screenshot', params)
+        logger.debug(f"get_scene_view_screenshot completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute get_scene_view_screenshot: {e}")
+        raise RuntimeError(f"Tool execution failed for get_scene_view_screenshot: {e}")
+
+
+async def capture_ui_canvas(
+    canvasPath: Annotated[
+        str | None,
+        Field(
+            description="""Optional path to the canvas in the scene hierarchy. If provided, the specified Canvas will be captured. If empty or null, the first Canvas found in the scene will be captured."""
+        ),
+    ] = None,
+) -> Any:
+    """Captures a screenshot of a UI Canvas. Use this tool to capture and analyze Unity UI Canvases in the Scene hierarchy after generating UI for validation."""
+    try:
+        logger.debug(f"Executing capture_ui_canvas with parameters: {locals()}")
+
+        # Prepare parameters for Unity RPC call
+        params = {}
+        if canvasPath is not None:
+            params['canvasPath'] = str(canvasPath)
+
+        # Execute Unity RPC call
+        result = await _unity_client.execute_request('capture_ui_canvas', params)
+        logger.debug(f"capture_ui_canvas completed successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to execute capture_ui_canvas: {e}")
+        raise RuntimeError(f"Tool execution failed for capture_ui_canvas: {e}")
+
+
+def register_tools(mcp: FastMCP, unity_client: UnityRpcClient) -> None:
+    """Register all tools from screenshot_tool_schema with the MCP server."""
+    global _mcp, _unity_client
+    _mcp = mcp
+    _unity_client = unity_client
+
+    # Register get_scene_view_screenshot
+    mcp.tool()(get_scene_view_screenshot)
+    # Register capture_ui_canvas
+    mcp.tool()(capture_ui_canvas)