* First pass at MCP client refactor
* Restore original text instructions
Well most of them, I modified a few
* Move configurators to their own folder
It's less clusterd
* Remvoe override for Windsurf because we no longer need to use it
* Add Antigravity configs
Works like Windsurf, but it sucks ass
* Add some docs for properties
* Add comprehensive MCP client configurators documentation
* Add missing imports (#7)
* Handle Linux paths when unregistering CLI commands
* Construct a JSON error in a much more secure fashion
* Remove temp folder from repo
* Ignore boot.config
* Remove buttons to download or rebuild the server
* Remove embedded MCP server in plugin
We'll reference the remote server in GitHub and configure clients to use `uvx`
* As much as possible, rip out logic that installs a server
* feat: migrate to uvx-based server configuration
- Replaced local server execution with uvx package-based configuration for improved reliability
- Added GetUvxCommand helper to generate correct package version command string
- Updated config generation to use `uvx mcp-for-unity` instead of local Python server
- Modified Codex and client configuration validation to support uvx-based setup
- Removed unused server source directory handling and related preferences
- Updated tests to verify uvx command generation
* Cleanup the temp folders created by tests
We don't commit temp folders, tests are expected to clean up after themselves
* The test kept failing but the results looked correct, floating point comparisons are not precise
* feat: migrate from local server to uvx-based configuration
- Replaced local server path detection with uvx-based package installation from git repository
- Updated all configuration generators to use structured uvx command parts (command, --from URL, package)
- Renamed UV path references to UVX for clarity and consistency
- Added GetUvxCommandParts() helper to centralize uvx command generation
- Added GetMcpServerGitUrl() to handle git repository URL construction
- Updated client configuration validation
* refactor: use dynamic package version instead of hardcoded value
* Update CI so it only updates the Server folder
* feat: implement uvx package source path resolution
- Added GetUvxPackageSourcePath method to locate unity-mcp package in uv cache by traversing git checkouts
- Replaced hardcoded "Dummy" path in PythonToolSyncProcessor with dynamic path resolution
- Added validation for Server directory structure and pyproject.toml to ensure correct package location
* refactor: replace Python tool syncing with custom tool registration system
- Removed PythonToolsAsset and file-based sync processor in favor of attribute-based tool discovery
- Implemented CustomToolRegistrationProcessor with automatic registration on startup and script reload
- Added registration enable/disable preference and force re-registration capability
* feat: add HTTP transport support and cache management
- Implemented HTTP transport option with configurable URL/port alongside existing stdio mode
- Added cache management service with menu item to clear uvx package cache
- Updated config builder to generate transport-specific arguments and VSCode type field based on selected mode
* refactor: simplify HTTP configuration to use URL-based approach
- Replaced separate host/port arguments with single --http-url parameter for cleaner configuration
- Updated server to parse URL and allow individual host/port overrides when needed
- Consolidated HTTP client implementation with connection testing and tool execution support
* refactor: standardize transport configuration with explicit --transport flag
- Replaced --enable-http-server flag with --transport choice parameter (stdio/http) for clearer intent
- Removed redundant HTTP port field from UI since HTTP mode uses the same URL/port as MCP client
- Simplified server startup logic by consolidating transport mode determination
* refactor: move MCP menu items under Window menu
* feat: restructure config generation for HTTP transport mode
- Changed HTTP mode to use URL-based configuration instead of command-line arguments
- Added proper cleanup of incompatible fields when switching between stdio and HTTP transports
- Moved uvx command parsing inside stdio-specific block to avoid unnecessary processing in HTTP mode
* feat: add local HTTP server management with Git URL override
- Implemented server management service with menu item to start local HTTP server in new terminal window
- Added Git URL override setting in advanced configuration to allow custom server source for uvx --from
- Integrated server management into service locator with validation for local-only server startup
* fix: remove automatic HTTP protocol prefix from URL field
- Removed auto-prefixing logic that added "http://" to URLs without protocol
- Added placeholder text to guide users on expected URL format
- Created dedicated url-field style class for better URL input styling
* feat: implement proper MCP session lifecycle with HTTP transport
- Added initialize, ping, and disconnect methods to HttpMcpClient for proper MCP protocol session management
- Implemented session ID tracking and header management for stateful HTTP connections
- Added cross-platform terminal launcher support for Windows and Linux (previously macOS-only)
* feat: implement JSON-RPC protocol for MCP tool execution
- Added proper JSON-RPC 2.0 request/response handling with request ID tracking
- Included MCP protocol headers (version, session ID) for standard compliance
- Added error handling for JSON-RPC error responses
* feat: improve text wrapping in editor window UI
- Added white-space: normal and flex-shrink properties to section headers and override labels to prevent text overflow
- Created new help-text style class for consistent formatting of help text elements
* refactor: refresh git URL override from EditorPrefs on validation
* fix: improve responsive layout for editor window settings
- Added flex-wrap to setting rows to prevent overflow on narrow windows
- Set flex-shrink: 0 on labels to maintain consistent width
- Replaced max-width and margin-left with flex-basis for better flex behavior
* refactor: improve thread safety in tool registration
- Capture Unity API calls on main thread before async operations to prevent threading issues
- Update RegisterAllTools to use Task.Run pattern instead of GetAwaiter().GetResult() to avoid potential deadlocks
- Add optional projectId parameter to RegisterAllToolsAsync for pre-captured values
* refactor: replace MCP tool calls with direct HTTP endpoints for tool registration
- Removed synchronous registration method and unused MCP bridge logic from CustomToolRegistrationService
- Changed tool registration to use direct HTTP POST to /register-tools endpoint instead of MCP protocol
- Added FastAPI HTTP routes alongside existing MCP tools for more flexible tool management access
* refactor: centralize HTTP endpoint URL management
- Created HttpEndpointUtility to normalize and manage base URLs consistently
- Replaced scattered EditorPrefs calls with utility methods that handle URL normalization
- Ensured base URL storage excludes trailing paths like "/mcp" for cleaner configuration
* refactor: simplify custom tools management with in-memory registry
- Removed CustomToolsManager and fastmcp_tool_registry modules in favor of inline implementation
- Replaced class-based tool management with direct HTTP route handlers using FastMCP's custom_route decorator
- Consolidated tool registration logic into simple dictionary-based storage with helper functions
* feat: add dynamic custom tool registration system
- Implemented CustomToolService to manage project-scoped tool registration with validation and conflict detection
- Added HTTP endpoints for registering, listing, and unregistering custom tools with proper error handling
- Converted health and registry endpoints from HTTP routes to MCP tools for better integration
* feat: add AutoRegister flag to control tool registration
- Added AutoRegister property to McpForUnityToolAttribute (defaults to true)
- Modified registration service to filter and only register tools with AutoRegister enabled
- Disabled auto-registration for all built-in tools that already exist server-side
* feat: add function signature generation for dynamic tools
- Implemented _build_signature method to create proper inspect.Signature objects for dynamically created tools
- Signature includes Context parameter and all tool parameters with correct required/optional defaults
- Attached generated signature to dynamic_tool functions to improve introspection and type checking
* refactor: remove unused custom tool registry endpoints
* test: add transport configuration validation for MCP client tests
- Added HTTP transport preference setup in test fixtures to ensure consistent behavior
- Implemented AssertTransportConfiguration helper to validate both HTTP and stdio transport modes
- Added tests to verify stdio transport fallback when HTTP preference is disabled
* refactor: simplify uvx path resolution to use PATH by default
- Removed complex platform-specific path detection logic and verification
- Changed to rely on system PATH environment variable instead of searching common installation locations
- Streamlined override handling to only use EditorPrefs when explicitly set by user
* feat: use serverUrl property for Windsurf HTTP transport
- Changed Windsurf configs to use "serverUrl" instead of "url" for HTTP transport to match Windsurf's expected format
- Added cleanup logic to remove stale transport properties when switching between HTTP and stdio modes
- Updated Windsurf to exclude "env" block (only required for Kiro), while preserving it for clients that need it
* feat: ensure client configurations stay current on each setup
- Removed skip logic for already-configured clients to force re-validation of core fields
- Added forced re-registration for ClaudeCode clients to keep transport settings up-to-date
* feat: add automatic migration for legacy embedded server configuration
- Created LegacyServerSrcMigration to detect and migrate old EditorPrefs keys on startup
- Automatically reconfigures all detected clients to use new uvx/stdio path
- Removes legacy keys only after successful migration to prevent data loss
* feat: add automatic stdio config migration on package updates
- Implemented StdIoVersionMigration to detect package version changes and refresh stdio MCP client configurations
- Added support for detecting stdio usage across different client types (Codex, VSCode, and generic JSON configs)
- Integrated version tracking via EditorPrefs to prevent redundant migrations
* Centralize where editor prefs are defined
It's really hard to get a view of all the editor prfes in use.
This should help humans and AI know what's going on at a glance
* Update custom tools docs
* refactor: consolidate server management UI into main editor window
- Removed server and maintenance menu items from top-level menu
- Moved "Start Local HTTP Server" and "Clear UVX Cache" buttons into editor window settings
- Added dynamic button state management based on transport protocol and server availability
* Don't show error logs when custom tools are already registerd with the server
* Only autoconnect to port 6400 if the user is using stdio for connections
* Don't double register tools on startup
* feat: switch to HTTP transport as default connection method
- Changed default transport from stdio to HTTP with server running on localhost:8080
- Added UI controls to start/stop local HTTP server directly from Unity window
- Updated all documentation and configuration examples to reflect HTTP-first approach with stdio as fallback option
* Automatically bump the versions in the READMEs.
The `main` branch gets updated before we do a release. Using versions helps users get a stable, tested installation
* docs: add HTTP transport configuration examples
- Added HTTP transport setup instructions alongside existing stdio examples
- Included port mapping and URL configuration for Docker deployments
- Reorganized client configuration sections to clearly distinguish between HTTP and stdio transports
* feat: add WebSocket-based plugin hub for Unity connections
- Implemented persistent WebSocket connections with session management, heartbeat monitoring, and command routing
- Created PluginRegistry for tracking active Unity instances with hash-based lookup and automatic reconnect handling
- Added HTTP endpoints for session listing and health checks, plus middleware integration for instance-based routing
* refactor: consolidate Unity instance discovery with shared registry
- Introduced StdioPortRegistry for centralized caching of Unity instance discovery results
- Refactored UnityConnection to use stdio_port_registry instead of direct PortDiscovery calls
- Improved error handling with specific exception types and enhanced logging clarity
* Use websockets so that local and remote MCP servers can communicate with Unity
The MCP server supports HTTP and stdio protocols, and the MCP clients use them to communicate.
However, communication from the MCP server to Unity is done on the local port 6400, that's somewhat hardcoded.
So we add websockets so oure remotely hosted MCP server has a valid connection to the Unity plugin, and can communicate with
- Created ProjectIdentityUtility for centralized project hash, name, and session ID management
- Moved command processing logic from MCPForUnityBridge to new TransportCommandDispatcher service
- Added WebSocket session ID and URL override constants to EditorPrefKeys
- Simplified command queue processing with async/await pattern and timeout handling
- Removed duplicate command execution code in favor of shared dispatcher implementation
* refactor: simplify port management and improve port field validation
- Removed automatic port discovery and fallback logic from GetPortWithFallback()
- Changed GetPortWithFallback() to return stored port or default without availability checks
- Added SetPreferredPort() method for explicit port persistence with validation
- Replaced Debug.Log calls with McpLog.Info/Warn for consistent logging
- Added port field validation on blur and Enter key press with error handling
- Removed automatic port waiting
* Launch the actual local webserver via the button
* Autoformat
* Minor fixes so the server can start
* Make clear uvx button work
* Don't show a dialog after clearing cache/starting server successfully
It's annoying, we can just log when successful, and popup if something failed
* We no longer need a Python importer
* This folder has nothing in it
* Cleanup whitespace
Most AI generated code contains extra space, unless they're hooked up to a linter. So I'm just cleaning up what's there
* We no longer need this folder
* refactor: move MCPForUnityBridge to StdioBridgeHost and reorganize transport layer
- Renamed MCPForUnityBridge class to StdioBridgeHost and moved to Services.Transport.Transports namespace
- Updated all references to StdioBridgeHost throughout codebase (BridgeControlService, TelemetryHelper, GitHub workflow)
- Changed telemetry bridge_version to use AssetPathUtility.GetPackageVersion() instead of hardcoded version
- Removed extensive inline comments and documentation throughout StdioBridgeHost
* Skip tools registration if the user is not connected to an HTTP server
* Fix VS Code configured status in UI
Serializing the config as dynamic and then reading null properties (in this case, args) caused the error. So we just walk through the properities and use JObject, handling null value explicitily
* Stop blocking the main thread when connecting via HTTP
Now that the bridge service is asynchronous, messages back and forth the server work well (including the websocket connection)
* Separate socket keep-alive interval from application keep-alive interval
Split the keep-alive configuration into two distinct intervals: _keepAliveInterval for application-level keep-alive and _socketKeepAliveInterval for WebSocket-level keep-alive. This allows independent control of socket timeout behavior based on server configuration while maintaining the application's keep-alive settings.
* Add a debug log line
* Fix McpLog.Debug method, so it actually reads the checkbox value from the user
* Add HTTP bridge auto-resume after domain reload
Implement HttpBridgeReloadHandler to automatically resume HTTP/HttpPush transports after Unity domain reloads, matching the behavior of the legacy stdio bridge. Add ResumeHttpAfterReload EditorPref key to persist state across reloads and expose ActiveMode property in IBridgeControlService to check current transport mode.
* Add health verification after HTTP bridge auto-resume
Trigger health check in all open MCPForUnityEditorWindow instances after successful HTTP bridge resume following domain reload. Track open windows using static HashSet and schedule async health verification via EditorApplication.delayCall to ensure UI updates reflect the restored connection state.
* Add name and path fields to code coverage settings
Initialize m_Name and m_Path fields in code coverage Settings.json to match Unity's expected settings file structure.
* Only register custom tools AFTER we established a healthy HTTP connection
* Convert custom tool handlers to async functions
Update dynamic_tool wrapper to use async/await pattern and replace synchronous send_with_unity_instance/send_command_with_retry calls with their async counterparts (async_send_with_unity_instance/async_send_command_with_retry).
* Correctly parse responses from Unity in the server so tools and resources can process them
We also move the logic to better places than the __init__.py file for tools, since they're shared across many files, including resources
* Make some clarifications for custom tools in docs
* Use `async_send_with_unity_instance` instead of `send_with_unity_instance`
The HTTP protocol doesn't working with blocking commands, so now we have our tools set up to work with HTTP and stdio fullly. It's coming together :-)
* Fix calls to async_send_with_unity_instance in manage_script
* Rename async_send_with_unity_instance to send_with_unity_instance
* Fix clear uv cache command
Helps a lot with local development
* Refactor HTTP server command generation into reusable method and display in UI
Extract HTTP server command building logic from StartLocalHttpServer into new TryGetLocalHttpServerCommand method. Add collapsible foldout in editor window to display the generated command with copy button, allowing users to manually start the server if preferred. Update UI state management to refresh command display when transport or URL settings change.
* Ctrl/Cmd + Shift + M now toggles the window
Might as well be able to close the window as well
* Fallback to a git URL that points to the main branch for the MCP git URL used by uvx
* Add test setup/teardown to preserve and reset Git URL override EditorPref
Implement OneTimeSetUp/OneTimeTearDown to save and restore the GitUrlOverride EditorPref state, and add SetUp to delete the key before each test. This ensures tests run with deterministic Git URLs while preserving developer overrides between test runs.
* Update docs, scripts and GH workflows to use the new MCP server code location
* Update plugin README
* Convert integration tests to async/await pattern
Update all integration tests to use pytest.mark.asyncio decorator and async/await syntax. Change test functions to async, update fake_send/fake_read mocks to async functions with **kwargs parameter, and patch async_send_command_with_retry instead of send_command_with_retry. Add await to all tool function calls that now return coroutines.
* Update image with new UI
* Remove unused HttpTransportClient client
Before I had the realization that I needed webscokets, this was my first attempt
* Remove copyright notice
* Add a guide to all the changes made for this version
A lot of code was written by AI, so I think it's important that humans can step through how all these new systems work, and know where to find things.
All of these docs were written by hand, as a way to vet that I understand what the code I wrote and generated are doing, but also to make ti easy to read for you.
* Organize imports and remove redundant import statements
Clean up import organization by moving imports to the top of the file, removing duplicate imports scattered throughout the code, and sorting imports alphabetically within their groups (standard library, third-party, local). Remove unnecessary import aliases and consolidate duplicate urlparse and time imports.
* Minor edits
* Fix stdio serializer to use the new type parameter like HTTP
* Fix: Automatic bridge reconnection after domain reload without requiring Unity focus
- Add immediate restart attempt in OnAfterAssemblyReload() when Unity is not compiling
- Enhanced compile detection to check both EditorApplication.isCompiling and CompilationPipeline.isCompiling
- Add brief port release wait in StdioBridgeHost before switching ports to reduce port thrash
- Fallback to delayCall/update loop only when Unity is actively compiling
This fixes the issue where domain reloads (e.g., script edits) would cause connection loss until Unity window was refocused, as EditorApplication.update only fires when Unity has focus.
* Make the server work in Docker
We use HTTP mode by default in docker, this is what will be hosted remotely if one chooses to.
We needed to update the uvicorn package to a version with websockets, at least so the right version is explicitly retrieved
* Cache project identity on initialization to avoid repeated computation
Add static constructor with [InitializeOnLoad] attribute to cache project hash and name at startup. Introduce volatile _identityCached flag and cached values (_cachedProjectName, _cachedProjectHash) to store computed identity. Schedule cache refresh on initialization and when project changes via EditorApplication.projectChanged event. Extract ComputeProjectHash and ComputeProjectName as private methods that perform the actual computation. Update public
* Fix typos
* Add unity_instance_middleware to py-modules list in pyproject.toml
* Remove Foldout UI elements and simplify HTTP server command section
Replace Foldout with VisualElement for http-server-command-section to display HTTP server command directly without collapsible wrapper. Remove unused manualConfigFoldout field and associated CSS styles. Remove unused _identityCached volatile flag from ProjectIdentityUtility as caching logic no longer requires it.
* Reduce height of HTTP command box
* Refresh HTTP server command display when Git URL override changes
* Make the box a bit smaller
* Split up main window into various components
Trying to avoid to monolithic files, this is easier to work, for humans and LLMs
* Update the setup wizard to be a simple setup popup built with UI toolkit
We also fix the Python/uv detectors. Instead of searching for binaries, we just test that they're available in the PATH
* Ensure that MCP configs are updated when users switch between HTTP and stdio
These only work for JSON configs, we'll have to handle Codex and Claude Code separately
* Detect Codex configuration when using HTTP or stdio configs
* Use Claude Code's list command to detect whether this MCP is configured
It's better than checking the JSON and it can verify both HTTP and stdio setups
* Fix and add tests for building configs
* Handle Unity reload gaps by retrying plugin session resolution
* Add polling support for long-running tools with state persistence
Introduce polling middleware to handle long-running operations that may span domain reloads. Add McpJobStateStore utility to persist tool state in Library folder across reloads. Extend McpForUnityToolAttribute with RequiresPolling and PollAction properties. Update Response helper with Pending method for standardized polling responses. Implement Python-side polling logic in custom_tool_service.py with configurable intervals and 10-minute timeout.
* Polish domain reload resilience tests and docs
* Refactor Response helper to use strongly-typed classes instead of anonymous objects
Replace static Response.Success/Error/Pending methods with SuccessResponse, ErrorResponse, and PendingResponse classes. Add IMcpResponse interface for type safety. Include JsonProperty attributes for serialization and JsonIgnore properties for backward compatibility with reflection-based tests. Update all tool and resource classes to use new response types.
* Rename Setup Wizard to Setup Window and improve UV detection on macOS/Linux
Rename SetupWizard class to SetupWindowService and update all references throughout the codebase. Implement platform-specific UV detection for macOS and Linux with augmented PATH support, including TryValidateUv methods and BuildAugmentedPath helpers. Split single "Open Installation Links" button into separate Python and UV install buttons. Update UI styling to improve installation section layout with proper containers and button
* Update guide on what's changed in v8
Lots of feedback, lots of changes
* Update custom tool docs to use new response objects
* Update image used in README
Slightly more up to date but not final
* Restructure backend
Just make it more organized, like typical Python projects
* Remove server_version.txt
* Feature/http instance routing (#5)
* Fix HTTP instance routing and per-project session IDs
* Drop confusing log message
* Ensure lock file references later version of uvicorn with key fixes
* Fix test imports
* Update refs in docs
---------
Co-authored-by: David Sarno <david@lighthaus.us>
* Generate the session ID from the server
We also make the identifying hashes longer
* Force LLMs to choose a Unity instance when multiple are connected
OK, this is outright the best OSS Unity MCP available
* Fix tests caused by changes in session management
* Whitespace update
* Exclude stale builds so users always get the latest version
* Set Pythonpath env var so Python looks at the src folder for modules
Not required for the fix, but it's a good guarantee regardless of the working directory
* Replace Optional type hints with modern union syntax (Type | None)
Update all Optional[Type] annotations to use the PEP 604 union syntax Type | None throughout the transport layer and mcp_source.py script
* Replace Dict type hints with modern dict syntax throughout codebase
Update all Dict[K, V] annotations to use the built-in dict[K, V] syntax across services, transport layer, and models for consistency with PEP 585
* Remove unused type imports across codebase
Clean up unused imports of Dict, List, and Path types that are no longer needed after migration to modern type hint syntax
* Remove the old telemetry test
It's working, we have a better integration test in any case
* Clean up stupid imports
No AI slop here lol
* Replace dict-based session data with Pydantic models for type safety
Introduce Pydantic models for all WebSocket messages and session data structures. Replace dict.get() calls with direct attribute access throughout the codebase. Add validation and error handling for incoming messages in PluginHub.
* Correctly call `ctx.info` with `await`
No AI slop here!
* Replace printf-style logging with f-string formatting across transport and telemetry modules
Convert all logger calls using %-style string formatting to use f-strings for consistency with modern Python practices. Update telemetry configuration logging, port discovery debug messages, and Unity connection logging throughout the codebase.
* Register custom tools via websockets
Since we'll end up using websockets for HTTP and stdio, this will ensure custom tools are available to both.
We want to compartmentalize the custom tools to the session. Custom tools in 1 unity project don't apply to another one.
To work with our multi-instance logic, we hide the custom tools behind a custom tool function tool. This is the execute_custom_tool function.
The downside is that the LLM has to query before using it.
The upside is that the execute_custom_tool function goes through the standard routing in plugin_hub, so custom tools are always isolated by project.
* Add logging decorator to track tool and resource execution with arguments and return values
Create a new logging_decorator module that wraps both sync and async functions to log their inputs, outputs, and exceptions. Apply this decorator to all tools and resources before the telemetry decorator to provide detailed execution traces for debugging.
* Fix JSONResponse serialization by converting Pydantic model to dict in plugin sessions endpoint
* Whitespace
* Move import of get_unity_instance_from_context to module level in unity_transport
Relocate the import from inside the with_unity_instance decorator function to the top of the file with other imports for better code organization and to avoid repeated imports on each decorator call.
* Remove the tool that reads resources
They don't perform well at all, and confuses the models most times.
However, if they're required, we'll revert
* We have buttons for starting and stopping local servers
Instead of a button to clear uv cache, we have start and stop buttons.
The start button pulls the latest version of the server as well.
The stop button finds the local process of the server and kills.
Need to test on Windows but it works well
* Consolidate cache management into ServerManagementService and remove standalone CacheManagementService
Move the ClearUvxCache method from CacheManagementService into ServerManagementService since cache clearing is primarily used during server operations. Remove the separate ICacheManagementService interface and CacheManagementService class along with their service locator registration. Update StartLocalServer to call the local ClearUvxCache method instead of going through the service locator.
* Update MCPForUnity/Editor/Helpers/ProjectIdentityUtility.cs
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* Update .github/workflows/claude-nl-suite.yml
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* Cancel existing background loops before starting a new connection
Nice bug found from CodeRabbit
* Try to kill all processes using the port of the local webserver
* Some better error handling when stopping a server
* Cache fallback session ID to maintain consistency when EditorPrefs are unavailable
Store the fallback session ID in a static field instead of generating a new GUID on each call when EditorPrefs are unavailable during batch tests. Clear the cached fallback ID when resetting the session to ensure a fresh ID is generated on the next session.
* Clean up empty parent temp folder after domain reload tests complete
Check if Assets/Temp folder is empty after deleting test-specific temp directories and remove it if no other files or directories remain. Also remove trailing blank lines from the file.
* Minor fixes
* Change "UV" to "uv" in strings. Capitlization looks weird
* Rename functions that capitalized "UV"
* Ensure WebSocket transport is properly stopped before disposing shared resources
Add disposal guard and call StopAsync() in Dispose() to prevent race conditions when disposing the WebSocket transport while background loops are still running. Log warnings if cleanup fails but continue with resource disposal.
* Replace volatile bool with Interlocked operations for reconnection flag to prevent race conditions
* Replace byte array allocation with ArrayPool to reduce GC pressure in WebSocket message receiving
Rent buffer from ArrayPool<byte>.Shared instead of allocating new byte arrays for each receive operation. Pre-size MemoryStream to 8192 bytes and ensure rented buffer is returned in finally block to prevent memory leaks.
* Consolidate some of the update/refresh logic
* UI tweak disable start/stop buttons while they code is being fired
* Add error dialog when Unity socket port persistence fails
* Rename WebSocketSessionId to SessionId in EditorPrefKeys
By the next version stdio will use Websockets as well, so why be redundant
* No need to send session ID in pong payload
* Add a debug message when we don't have an override for the uvx path
* Remove unused function
* Remove the unused verifyPath argument
* Simplify server management logic
* Remove unused `GetUvxCommand()` function
We construct it in parts now
* Remove `IsUvxDetected()`
The flow changed so it checks editor prefs and then defaults to the command line default. So it's always true.
* Add input validation and improve shell escaping in CreateTerminalProcessStartInfo
- Validate command is not empty before processing
- Strip carriage returns and newlines from command
- macOS: Use osascript directly instead of bash to avoid shell injection, escape backslashes and quotes for AppleScript
- Windows: Add window title and escape quotes in command
- Linux: Properly escape single quotes for bash -c and double quotes for process arguments
* Update technical changes guide
* Add custom_tools resource and execute_custom_tool to README documentation
* Update v8 docs
* Update docs UI image
* Handle when properties are sent as a JSON string in manage_asset
* Fix backend tests
---------
Co-authored-by: David Sarno <david@lighthaus.us>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* Add a function to reload the domain
Closes#357
* feat: restructure server instructions into workflow-focused format
- Reorganized instructions from flat bullet list into categorized workflow sections
- Emphasized critical script management workflow with numbered steps
- Improved readability and scannability for AI agents using the MCP server
It doesn't make sense to repeat the fucnction tools, they're already parsed
* docs: reorder tool list alphabetically in README + add reload_domain tool
* feat: add Unity editor state and project info resources
- Implemented resources for querying active tool, editor state, prefab stage, selection, and open windows
- Added project configuration resources for layers and project metadata
- Organized new resources into Editor and Project namespaces for better structure
* feat: clarify script management workflow in system prompt
- Expanded guidance to include scripts created by any tool, not just manage_script
- Added "etc" to tools examples for better clarity
* refactor: remove reload_domain tool and update script management workflow
- Removed reload_domain tool as Unity automatically recompiles scripts when modified
- Updated script management instructions to rely on editor_state polling and console checking instead of manual domain reload
- Simplified workflow by removing unnecessary manual recompilation step
* Change name of menu items resource as the LLM seems it
* refactor: reorganize tests into src/tests/integration directory
- Moved all test files from root tests/ to MCPForUnity/UnityMcpServer~/src/tests/integration/ for better organization
- Added conftest.py with telemetry and dependency stubs to simplify test setup
- Removed redundant path manipulation and module loading code from individual test files
* feat: expand Unity test workflow triggers
- Run tests on all branches instead of only main
- Add pull request trigger to catch issues before merge
- Maintain path filtering to run only when relevant files change
* chore: add GitHub Actions workflow for Python tests
- Configured automated testing on push and pull requests using pytest
- Set up uv for dependency management and Python 3.10 environment
- Added test results artifact upload for debugging failed runs
* refactor: update import path for fastmcp Context
* docs: update development setup instructions to use uv
- Changed installation commands from pip to uv pip for better dependency management
- Updated test running instructions to use uv run pytest
- Added examples for running integration and unit tests separately
* Formatting [skip ci]
* refactor: optimize CI workflow with path filters and dependency installation
- Added path filters to only trigger tests when Python source or workflow files change
- Split dependency installation into sync and dev install steps for better clarity
- Fixed YAML indentation for improved readability
* Update .github/workflows/python-tests.yml
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* fix: standardize test mode values to match Unity's naming convention
- Changed default mode from "edit" to "EditMode" in C# code
- Updated Python tool to use "EditMode" and "PlayMode" instead of lowercase variants
* refactor: convert test imports to relative imports
- Changed absolute imports to relative imports in integration tests for better package structure
- Removed test packages from pyproject.toml package list
* refactor: use Field with default_factory for mutable default in TagsResponse
* refactor: remove duplicate PrefabStageUtility call
* Update this as well [skip ci]
* Update MCPForUnity/UnityMcpServer~/src/tests/integration/test_script_tools.py
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* chore: remove pull_request triggers from test workflows [skip ci]
It's already covered by pushes
* refactor: update resource function return types to include MCPResponse union
* refactor: remove manual domain reload tool
- Removed reload_domain tool as Unity handles script recompilation automatically
- Updated documentation to reflect automatic compilation workflow
- Simplified script management workflow instructions in server description
* refactor: add context support to resource handlers
- Updated all resource handlers to accept Context parameter for Unity instance routing
- Replaced direct async_send_command_with_retry calls with async_send_with_unity_instance wrapper
- Added imports for get_unity_instance_from_context and async_send_with_unity_instance helpers
* fix: correct grammar in menu items documentation
* docs: update README with expanded tools and resources documentation
- Added new tools: manage_prefabs, create_script, delete_script, get_sha
- Added new resources: editor state, windows, project info, layers, and tags
- Clarified manage_script as compatibility router with recommendation to use newer edit tools
- Fixed run_test to run_tests for consistency
* refactor: convert unity_instances function to async [skip ci]
- Changed function signature from synchronous to async
- Added await keywords to ctx.info() and ctx.error() calls to properly handle async context methods
---------
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* Remove legacy UI and correct priority ordering of menu items
* Remove old UI screen
Users now have the new UI alone, less confusing and more predictable
* Remove unused config files
* Remove test for window that doesn't exist
* Remove unused code
* Remove dangling .meta file
* refactor: remove client configuration step from setup wizard
* refactor: remove menu item attributes and manual window actions from Python tool sync
* feat: update minimum Python version requirement from 3.10 to 3.11
The docs have 3.12. However, feature wise it seems that 3.11 is required
* fix: replace emoji warning symbol with unicode character in setup wizard dialogs
* docs: reorganize images into docs/images directory and update references
* docs: add UI preview image to README
* docs: add run_test function and resources section to available tools list
The recent changes should close#311
* fix: add SystemRoot env var to Windows config to support Python path resolution
Closes#315
* refactor: consolidate package installation and detection into unified lifecycle manager
Duplicate code for pretty much no reason, as they both initialized there was a small chance of a race condition as well. Consolidating made sense here
* Doc fixes from CodeRabbit
* Excellent bug catch from CodeRabbit
* fix: preserve existing environment variables when updating codex server config
* Update docs so the paths match the original name
* style: fix list indentation in README-DEV.md development docs
* refactor: simplify env table handling in CodexConfigHelper by removing preservation logic
* refactor: simplify configuration logic by removing redundant change detection
Always overwrite configs
* feat: ensure config directory exists before writing config files
* feat: persist server installation errors and show retry UI instead of auto-marking as handled
* refactor: consolidate configuration helpers by merging McpConfigFileHelper into McpConfigurationHelper
* Small fixes from CodeRabbit
* Remove test because we overwrite Codex configs
* Remove unused function
* feat: improve server cleanup and process handling on Windows
- Added DeleteDirectoryWithRetry helper to handle Windows file locking with retries and readonly attribute clearing
- Implemented KillWindowsUvProcesses to safely terminate Python processes in virtual environments using WMIC
- Extended TryKillUvForPath to work on Windows, preventing file handle locks during server deletion
- Improved error messages to be more descriptive about file locking issues
- Replaced direct Directory.Delete calls with
* fix: improve TCP socket cleanup to prevent CLOSE_WAIT states
- Added proper socket shutdown sequence using Socket.Shutdown() before closing connections
- Enhanced error handling with specific catches for SocketException vs general exceptions
- Added debug logging for socket shutdown errors to help diagnose connection issues
- Restructured HandleClientAsync to ensure socket cleanup happens in the correct order
- Implemented proper socket teardown in both client handling and connection cleanup paths
* Update github-repo-stats.yml
* pytest: make harness MCPForUnity-only; remove UnityMcpBridge paths from tests; route tools.manage_script via unity_connection for reliable monkeypatching; fix ctx usage; all tests green (39 pass, 5 skip, 7 xpass)
* Add missing meta for MaterialMeshInstantiationTests.cs (Assets)
* bridge/tools/manage_script: fix missing unity_connection prefix in validate_script; tests: tidy manage_script_uri unused symbols and arg names
* tests: rename to script_apply_edits_module; extract DummyContext to tests/test_helpers and import; add telemetry stubs in tests to avoid pyproject I/O
* tests: import cleanup and helper extraction; telemetry: prefer plain config and opt-in env override; test stubs and CWD fixes; exclude Bridge from pytest discovery
* chore: remove unintended .wt-origin-main gitlink and ignore folder
* tests: nit fixes (unused-arg stubs, import order, path-normalized ignore hook); telemetry: validate config endpoint; read_console: action optional
* Add development dependencies to pyproject.toml
- Add [project.optional-dependencies] section with dev group
- Include pytest>=8.0.0 and pytest-anyio>=0.6.0
- Add Development Setup section to README-DEV.md with installation and testing instructions
* Revert "Update github-repo-stats.yml"
This reverts commit 8ae595d2f4f2525b0e44ece948883ea37138add4.
* test: improve test clarity and modernize asyncio usage
- Add explanation for 200ms timeout in backpressure test
- Replace manual event loop creation with asyncio.run()
- Add assertion message with actual elapsed time for easier debugging
* refactor: remove duplicate DummyContext definitions across test files
Replace 7 duplicate DummyContext class definitions with imports from tests.test_helpers.
This follows DRY principles and ensures consistency across the test suite.
* chore: remove unused _load function from test_edit_strict_and_warnings.py
Dead code cleanup - function was no longer used after refactoring to dynamic tool registration.
* docs: add comment explaining CWD manipulation in telemetry test
Clarify why os.chdir() is necessary: telemetry.py calls get_package_version()
at module load time, which reads pyproject.toml using a relative path.
Acknowledges the fragility while explaining why it's currently required.
* Fix issue #308: Find py files in MCPForUnityTools and version.txt
This allows for auto finding new tools. A good dir on a custom tool would look like this:
CustomTool/
├── CustomTool.MCPEnabler.asmdef
├── CustomTool.MCPEnabler.asmdef.meta
├── ExternalAssetToolFunction.cs
├── ExternalAssetToolFunction.cs.meta
├── external_asset_tool_function.py
├── external_asset_tool_function.py.meta
├── version.txt
└── version.txt.meta
CS files are left in the tools folder. The asmdef is recommended to allow for dependency on MCPForUnity when MCP For Unity is installed:
asmdef example
{
"name": "CustomTool.MCPEnabler",
"rootNamespace": "MCPForUnity.Editor.Tools",
"references": [
"CustomTool",
"MCPForUnity.Editor"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}
* Follow-up: address CodeRabbit feedback for #308 (<GetToolsFolderIdentifier was duplicated>)
* Follow-up: address CodeRabbit feedback for #308 – centralize GetToolsFolderIdentifier, fix tools copy dir, and limit scan scope
* Fixing so the MCP don't removes _skipDirs e.g. __pycache__
* skip empty folders with no py files
* Rabbit: "Fix identifier collision between different package roots."
* Update MCPForUnity/Editor/Helpers/ServerInstaller.cs
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* Rabbbit: Cleanup may delete server’s built-in tool subfolders — restrict to managed names.
* Fixed minor + missed onadding rabit change
* Revert "Fixed minor + missed onadding rabit change"
This reverts commit 571ca8c5de3d07da3791dad558677909a07e886d.
* refactor: remove Unity project tools copying and version tracking functionality
* refactor: consolidate module discovery logic into shared utility function
* Remove unused imports
* feat: add Python tool registry and sync system for MCP server integration
* feat: add auto-sync processor for Python tools with Unity editor integration
* feat: add menu item to reimport all Python files in project
Good to give users a manual option
* Fix infinite loop error
Don't react to PythonToolAsset changes - it only needs to react to Python file changes.
And we also batch asset edits to minimise the DB refreshes
* refactor: move Python tool sync menu items under Window/MCP For Unity/Tool Sync
* Update docs
* Remove duplicate header
* feat: add OnValidate handler to sync Python tools when asset is modified
This fixes the issue with deletions in the asset, now file removals are synced
* test: add unit tests for Python tools asset and sync services
* Update MCPForUnity/Editor/Helpers/PythonToolSyncProcessor.cs
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* style: remove trailing whitespace from Python tool sync files
* test: remove incomplete unit tests from ToolSyncServiceTests
* perf: optimize Python file reimport by using AssetDatabase.FindAssets instead of GetAllAssetPaths
---------
Co-authored-by: Johan Holtby <72528418+JohanHoltby@users.noreply.github.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* deps: add tomli>=2.3.0 dependency to UnityMcpServer package
* feat: dynamically fetch package version from pyproject.toml for telemetry
* Add pydantic
* feat: add resource registry for MCP resource auto-discovery
* feat: add telemetry decorator for tracking MCP resource usage
* feat: add auto-discovery and registration system for MCP resources
* feat: add resource registration to MCP server initialization
* feat: add MCPResponse model class for standardized API responses
* refactor: replace Debug.Log calls with McpLog wrapper for consistent logging
* feat: add test discovery endpoints for Unity Test Framework integration
We haven't connected them as yet, still thinking about how to do this neatly
* Fix server setup
* refactor: reduce log verbosity by changing individual resource/tool registration logs to debug level
* chore: bump mcp[cli] dependency from 1.15.0 to 1.17.0
* refactor: remove Context parameter and add uri keyword argument in resource decorator
The Context parameter doesn't work on our version of FastMCP
* chore: upgrade Python base image to 3.13 and simplify Dockerfile setup
* fix: apply telemetry decorator before mcp.tool to ensure proper wrapping order
* fix: swap order of telemetry and resource decorators to properly wrap handlers
* fix: update log prefixes for consistency in logging methods
* Fix compile errors
* feat: extend command registry to support both tools and resources
* Run get tests as a coroutine because it doesn't return results immediately
This works but it spams logs like crazy, maybe there's a better/simpler way
* refactor: migrate from coroutines to async/await for test retrieval and command execution
* feat: add optional error field to MCPResponse model
* Increased timeout because loading tests can take some time
* Make message optional so error responses that only have success and error don't cause Pydantic errors
* Set max_retries to 5
This connection module needs a lookover. The retries should be an exponential backoff and we could structure why it's failing so much
* Use pydantic model to structure the error output
* fix: initialize data field in GetTestsResponse to avoid potential errors
* Don't return path parameter
* feat: add Unity test runner execution with structured results and Python bindings
* refactor: simplify GetTests by removing mode filtering and related parsing logic
* refactor: move test runner functionality into dedicated service interface
* feat: add resource retrieval telemetry tracking with new record type and helper function
* fix: convert tool functions to async and await ctx.info calls
* refactor: reorganize menu item functionality into separate execute and get commands
An MCP resource for retrieval, and a simple command to execute. Because it's a resource, it's easier for the user to see what's in the menu items
* refactor: rename manage_menu_item to execute_menu_item and update tool examples to use async/await
We'll eventually put a section for resources
* Revert "fix: convert tool functions to async and await ctx.info calls"
This reverts commit 012ea6b7439bd1f2593864d98d03d9d95d7bdd03.
* fix: replace tomllib with tomli for Python 3.10 compatibility in telemetry module
* Remove confusing comment
* refactor: improve error handling and simplify test retrieval logic in GetTests commands
* No cache by default
* docs: remove redundant comment for HandleCommand method in ExecuteMenuItem
* First pass at new UI
* Point to new UI
* Refactor: New Service-Based MCP Editor Window Architecture
We separate the business logic from the UI rendering of the new editor window with new services.
I didn't go full Dependency Injection, not sure if I want to add those deps to the install as yet, but service location is fairly straightforward.
Some differences with the old window:
- No more Auto-Setup, users will manually decide what they want to do
- Removed Python detection warning, we have a setup wizard now
- Added explicit path overrides for `uv` and the MCP server itself
* style: add flex-shrink and overflow handling to improve UI element scaling
* fix: update UI configuration and visibility when client status changes
* feat: add menu item to open legacy MCP configuration window
* refactor: improve editor window lifecycle handling with proper update subscription
* feat: add auto-verification of bridge health when connected
* fix: update Claude Code MCP server registration to use lowercase unityMCP name and correct the manual installation instructions
* fix: add Claude CLI directory to PATH for node/nvm environments
* Clarify how users will see MCP tools
* Add a keyboard shortcut to open the window
* feat: add server download UI and improve installation status messaging
This is needed for the Unity Asset Store, which doesn't have the Python server embedded.
* feat: add dynamic asset path detection to support both Package Manager and Asset Store installations
* fix: replace unicode emojis with escaped characters in status messages
* feat: add server package creation and GitHub release publishing to version bump workflow
* fix: add v prefix to server package filename in release workflow
* Fix download location
* style: improve dropdown and settings layout responsiveness with flex-shrink and max-width
* feat: add package.json version detection and refactor path utilities
* refactor: simplify imports and use fully qualified names in ServerInstaller.cs
* refactor: replace Unity Debug.Log calls with custom McpLog class
* fix: extract server files to temp directory before moving to final location
* docs: add v6 UI documentation and screenshots with service architecture overview
* docs: add new UI Toolkit-based editor window with service architecture and path overrides
* feat: improve package path resolution to support Package Manager and Asset Store installations
* Change Claude Code's casing back to "UnityMCP"
There's no need to break anything as yet
* fix: update success dialog text to clarify manual bridge start requirement
* refactor: move RefreshDebounce and ManageScriptRefreshHelpers classes inside namespace
* feat: add Asset Store fallback path detection for package root lookup
* fix: update server installation success message to be more descriptive
* refactor: replace Unity Debug.Log calls with custom McpLog utility
* fix: add file existence check before opening configuration file
* refactor: simplify asset path handling and remove redundant helper namespace references
* docs: update code block syntax highlighting in UI changes doc
* docs: add code block syntax highlighting for file structure example
* feat: import UnityEditor.UIElements namespace for UI components for Unity 2021 compatibility
* refactor: rename Python server references to MCP server for consistency
* fix: reset client status label color after error state is cleared
* Replace the phrase "Python server" with "MCP server"
* MInor doc clarification
* docs: add path override methods for UV and Claude CLI executables
* docs: update service locator registration method name from SetCustomImplementation to Register
* Copy UnityMcpBridge into a new MCPForUnity folder
This is to close#284
* refactor: rename UnityMcpBridge directory to MCPForUnity in docs
* chore: rename UnityMcpBridge directory to MCPForUnity across workflow files
* chore: rename UnityMcpBridge directory to MCPForUnity across all files
* refactor: update import paths from UnityMcpBridge to MCPForUnity across test files
* fix: update module import paths to use MCPForUnity instead of UnityMcpBridge
* chore: update unity-mcp package path to MCPForUnity directory
* feat: add OneTimeSetUp to initialize CommandRegistry before tests run
Hopefully fix the CI failures
* Apply recent fix to new folder
* Temporarily trigger tests to see if CI works
* Revert "Temporarily trigger tests to see if CI works"
It works!
This reverts commit 8c6eaaad07545cef047769f2c52fe506545a8161.
* Add a decorate that wraps around the `mcp.tool` decorator.
This will allow us to more easily collect tools
* Register tools that's defined in the tools folder
* Update Python tools to use new decorator
* Convert script_apply_edits tool
* Convert last remaining tools with new decorator
* Create an attribute so we can identify tools via Reflection
* Add attribute to all C# tools
* Use reflection to load tools
* Initialize command registry to load tools at startup
* Update tests
* Move Dev docs to docs folder
* Add docs for adding custom tools
* Update function docs for Python decorator
* Add working example of adding a screenshot tool
* docs: update relative links in README files
Updated the relative links in both README-DEV.md and README-DEV-zh.md to use direct filenames instead of paths relative to the docs directory, improving link correctness when files are accessed from the root directory.
* docs: update telemetry documentation path reference
Updated the link to TELEMETRY.md in README.md to point to the new docs/ directory location to ensure users can access the telemetry documentation correctly. Also moved the TELEMETRY.md file to the docs/ directory as part of the documentation restructuring.
* rename CursorHelp.md to docs/CURSOR_HELP.md
Moved the CursorHelp.md file to the docs directory to better organize documentation files and improve project structure.
* docs: update CUSTOM_TOOLS.md with improved tool naming documentation and path corrections
- Clarified that the `name` argument in `@mcp_for_unity_tool` decorator is optional and defaults to the function name
- Added documentation about using all FastMCP `mcp.tool` function decorator options
- Updated class naming documentation to mention snake_case conversion by default
- Corrected Python file path from `tools/screenshot_tool.py` to `UnityMcpServer~/src/tools/screenshot_tool.py`
- Enhanced documentation for tool discovery and usage examples
* docs: restructure development documentation and add custom tools guide
Rearranged the development section in README.md to better organize the documentation flow. Added a dedicated section for "Adding Custom Tools" with a link to the new CUSTOM_TOOLS.md file, and renamed the previous "For Developers" section to "Contributing to the Project" to better reflect its content. This improves discoverability and organization of the development setup documentation.
* docs: update developer documentation and add README links
- Added links to developer READMEs in CUSTOM_TOOLS.md to guide users to the appropriate documentation
- Fixed typo in README-DEV.md ("roote" → "root") for improved clarity
- These changes improve the developer experience by providing better documentation navigation and correcting technical inaccuracies
* feat(tools): enhance tool registration with wrapped function assignment
Updated the tool registration process to properly chain the mcp.tool decorator and telemetry wrapper, ensuring the wrapped function is correctly assigned to tool_info['func'] for proper tool execution and telemetry tracking. This change improves the reliability of tool registration and monitoring.
* Remove AI generated code that was never used...
* feat: Rebuild MCP server installation with embedded source
Refactored the server repair logic to implement a full rebuild of the MCP server installation using the embedded source. The new RebuildMcpServer method now:
- Uses embedded server source instead of attempting repair of existing installation
- Deletes the entire existing server directory before re-copying
- Handles UV process cleanup for the target path
- Simplifies the installation flow by removing the complex Python environment repair logic
- Maintains the same installation behavior but with a cleaner, more reliable rebuild approach
This change improves reliability of server installations by ensuring a clean slate rebuild rather than attempting to repair potentially corrupted environments.
* Add the rebuild server step
* docs: clarify tool description field requirements and client compatibility
* fix: move initialization flag after tool discovery to prevent race conditions
* refactor: remove redundant TryParseVersion overrides in platform detectors
* refactor: remove duplicate UV validation code from platform detectors
* Update UnityMcpBridge/Editor/Tools/CommandRegistry.cs
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
* refactor: replace WriteToConfig reflection with direct McpConfigurationHelper call
---------
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
Jordon
Marcus Sanatan
dsarno