* Log a message with implicit URI changes
Small update for #542
* Log a message with implicit URI changes
Small update for #542
* Add helper scripts to update forks
* fix: improve HTTP Local URL validation UX and styling specificity
- Rename CSS class from generic "error" to "http-local-url-error" for better specificity
- Rename "invalid-url" class to "http-local-invalid-url" for clarity
- Disable httpServerCommandField when URL is invalid or transport not HTTP Local
- Clear field value and tooltip when showing validation errors
- Ensure field is re-enabled when URL becomes valid
* feat: Add project-scoped tools flag to control custom tool registration behavior
Add `--project-scoped-tools` CLI flag and `UNITY_MCP_PROJECT_SCOPED_TOOLS` environment variable to control whether custom tools are registered globally or scoped to specific Unity projects.
Closes#416
* Add .meta file
* feat: Add project-scoped tools toggle for local HTTP transport
Add UI toggle in Connection section to control project-scoped tools flag when using HTTP Local transport. The toggle:
- Defaults to enabled (true)
- Persists state in EditorPrefs
- Only displays when HTTP Local transport is selected
- Automatically appends `--project-scoped-tools` flag to uvx server command
- Updates manual config display when toggled
* Update Server/src/services/custom_tool_service.py
Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com>
* Pass project_scoped_tools flag directly without environment variable conversion
Remove unnecessary environment variable conversion for project_scoped_tools flag.
* fix: Improve error handling and logging in global custom tool registration
Split exception handling to distinguish between expected RuntimeError (service not initialized) and unexpected errors.
---------
Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com>
* fix: reduce per-frame GC allocations causing editor hitches (issue #577)
Eliminate memory allocations that occurred every frame, which triggered
garbage collection spikes (~28ms) approximately every second.
Changes:
- EditorStateCache: Skip BuildSnapshot() entirely when state unchanged
(check BEFORE building). Increased poll interval from 0.25s to 1.0s.
Cache DeepClone() results to avoid allocations on GetSnapshot().
- TransportCommandDispatcher: Early exit before lock/list allocation
when Pending.Count == 0, eliminating per-frame allocations when idle.
- StdioBridgeHost: Same early exit pattern for commandQueue.
- MCPForUnityEditorWindow: Throttle OnEditorUpdate to 2-second intervals
instead of every frame, preventing expensive socket checks 60+/sec.
Fixes GitHub issue #577: High performance impact even when MCP server is off
* fix: prevent multiple domain reloads when calling refresh_unity (issue #577)
Root Cause:
- send_command() had a hardcoded retry loop (min 6 attempts) on connection errors
- Each retry resent the refresh_unity command, causing Unity to reload 6 times
- retry_on_reload=False only controlled reload-state retries, not connection retries
The Fix:
1. Unity C# (MCPForUnity/Editor):
- Added --reinstall flag to uvx commands in dev mode
- Ensures local development changes are picked up by uvx/Claude Code
- Applies to all client configurators (Claude Code, Codex, etc.)
2. Python Server (Server/src):
- Added max_attempts parameter to send_command()
- Pass max_attempts=0 when retry_on_reload=False
- Fixed type handling in refresh_unity.py (handle MCPResponse objects)
- Added timeout to connection error recovery conditions
- Recovery logic now returns success instead of error to prevent client retries
Changes:
- MCPForUnity/Editor: Added --reinstall to dev mode uvx commands
- Server/refresh_unity.py: Fixed type handling, improved error recovery
- Server/unity_connection.py: Added max_attempts param, disable retries when retry_on_reload=False
Result: refresh_unity with compile=request now triggers only 1 domain reload instead of 6
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: UI and server stability improvements
Unity Editor (C#):
- Fix "Resuming..." stuck state when manually clicking End Session
Clear ResumeStdioAfterReload and ResumeHttpAfterReload flags in
OnConnectionToggleClicked and EndOrphanedSessionAsync to prevent
UI from getting stuck showing "Resuming..." with disabled button
- Remove unsupported --reinstall flag from all uvx command builders
uvx does not support --reinstall and shows warning when used
Use --no-cache --refresh instead for dev mode cache busting
Python Server:
- Add "aborted" to connection error patterns in refresh_unity
Handle WinError 10053 (connection aborted) gracefully during
Unity domain reload, treating it as expected behavior
- Add WindowsSafeRotatingFileHandler to suppress log rotation errors
Windows file locking prevents log rotation when file is open by
another process; catch PermissionError to avoid noisy stack traces
- Fix packaging: add py-modules = ["main"] to pyproject.toml
setuptools.packages.find only discovers packages (directories with
__init__.py), must explicitly list standalone module files
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* docs: improve refresh_unity connection loss handling documentation
Add detailed comments and logging to clarify why connection loss during
compile is treated as success (expected domain reload behavior, not failure).
This addresses PR feedback about potentially masking real connection errors.
The logic is intentional and correct:
- Connection loss only treated as success when compile='request'
- Domain reload causing disconnect is expected Unity behavior
- Subsequent wait_for_ready loop validates Unity becomes ready
- Prevents multiple domain reload loops (issue #577)
Added logging for observability:
- Info log when expected disconnect detected
- Warning log for non-recoverable errors
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: add missing logger import in refresh_unity
Missing logger import causes NameError at runtime when connection
loss handling paths are triggered (lines 82 and 91).
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: address code review feedback on thread safety and semantics
Addresses four issues raised in code review:
1. EditorStateCache.GetSnapshot() - Remove shared cached clone
- Revert to always returning fresh DeepClone() to prevent mutation bugs
- Main GC optimization remains: state-change detection prevents
unnecessary _cached rebuilds (the expensive operation)
- Removed _cachedClone and _cachedCloneSequence fields
2. refresh_unity.py - Fix blocking reason terminology mismatch
- Changed "asset_refresh" to "asset_import" to match activityPhase
values from EditorStateCache.cs
- Ensures asset import is correctly detected as blocking state
3. TransportCommandDispatcher - Fix unsynchronized Count access
- Moved Pending.Count check inside PendingLock
- Prevents data races and InvalidOperationException from concurrent
dictionary access
4. StdioBridgeHost - Fix unsynchronized Count access
- Moved commandQueue.Count check inside lockObj
- Ensures all collection access is properly serialized
All changes maintain the GC allocation optimizations while fixing
thread safety violations and semantic contract changes.
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: address code review feedback on thread safety and timeout handling
- refresh_unity.py: Track readiness explicitly and return failure on timeout
instead of silently returning success when wait loop exits without confirming
ready_for_tools=true
- McpClientConfiguratorBase.cs: Add thread safety guard for Configure() call
in CheckStatusWithProjectDir(). Changed default attemptAutoRewrite to false
and added runtime check to prevent calling Configure() from background threads.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
* refactor: Split ParseColorOrDefault into two overloads and change default to Color.white
* Auto-format Python code
* Remove unused Python module
* Refactored VFX functionality into multiple files
Tested everything, works like a charm
* Rename ManageVfx folder to just Vfx
We know what it's managing
* Clean up whitespace on plugin tools and resources
* Make ManageGameObject less of a monolith by splitting it out into different files
* Remove obsolete FindObjectByInstruction method
We also update the namespace for ManageVFX
* Add local test harness for fast developer iteration
Scripts for running the NL/T/GO test suites locally against a GUI Unity
Editor, complementing the CI workflows in .github/workflows/.
Benefits:
- 10-100x faster than CI (no Docker startup)
- Real-time Unity console debugging
- Single test execution for rapid iteration
- Auto-detects HTTP vs stdio transport
Usage:
./scripts/local-test/setup.sh # One-time setup
./scripts/local-test/quick-test.sh NL-0 # Run single test
./scripts/local-test/run-nl-suite-local.sh # Full suite
See scripts/local-test/README.md for details.
Also updated .gitignore to:
- Allow scripts/local-test/ to be tracked
- Ignore generated artifacts (reports/*.xml, .claude/local/, .unity-mcp/)
* Fix issue #525: Save dirty scenes for all test modes
Move SaveDirtyScenesIfNeeded() call outside the PlayMode conditional
so EditMode tests don't get blocked by Unity's "Save Scene" modal dialog.
This prevents MCP from timing out when running EditMode tests with unsaved
scene changes.
* refactor: Consolidate editor state resources into single canonical implementation
Merged EditorStateV2 into EditorState, making get_editor_state the canonical resource. Updated Unity C# to use EditorStateCache directly. Enhanced Python implementation with advice/staleness enrichment, external changes detection, and instance ID inference. Removed duplicate EditorStateV2 resource and legacy fallback mapping.
* Validate editor state with Pydantic models in both C# and Python
Added strongly-typed Pydantic models for EditorStateV2 schema in Python and corresponding C# classes with JsonProperty attributes. Updated C# to serialize using typed classes instead of anonymous objects. Python now validates the editor state payload before returning it, catching schema mismatches early.
* Consolidate run_tests and run_tests_async into single async implementation
Merged run_tests_async into run_tests, making async job-based execution the default behavior. Removed synchronous blocking test execution. Updated RunTests.cs to start test jobs immediately and return job_id for polling. Changed TestJobManager methods to internal visibility. Updated README to reflect single run_tests_async tool. Python implementation now uses async job pattern exclusively.
* Validate test job responses with Pydantic models in Python
* Change resources URI from unity:// to mcpforunity://
It should reduce conflicts with other Unity MCPs that users try, and to comply with Unity's requests regarding use of their company and product name
* Update README with all tools + better listing for resources
* Update other references to resources
* Updated translated doc - unfortunately I cannot verify
* Update the Chinese translation of the dev docks
* Change menu item from Setup Window to Local Setup Window
We now differentiate whether it's HTTP local or remote
* Fix URIs for menu items and tests
* Shouldn't have removed it
* fix: add missing FAST_FAIL_TIMEOUT constant in PluginHub
The FAST_FAIL_TIMEOUT class attribute was referenced on line 149 but never
defined, causing AttributeError on every ping attempt. This error was silently
caught by the broad 'except Exception' handler, causing all fast-fail commands
(read_console, get_editor_state, ping) to fail after 6 seconds of retries with
'ping not answered' error.
Added FAST_FAIL_TIMEOUT = 10 to define a 10-second timeout for fast-fail
commands, matching the intent of the existing fast-fail infrastructure.
* feat(ScriptableObject): enhance dry-run validation for AnimationCurve and Quaternion
Dry-run validation now validates value formats, not just property existence:
- AnimationCurve: Validates structure ({keys:[...]} or direct array), checks
each keyframe is an object, validates numeric fields (time, value, inSlope,
outSlope, inWeight, outWeight) and integer fields (weightedMode)
- Quaternion: Validates array length (3 for Euler, 4 for raw) or object
structure ({x,y,z,w} or {euler:[x,y,z]}), ensures all components are numeric
Refactored shared validation helpers into appropriate locations:
- ParamCoercion: IsNumericToken, ValidateNumericField, ValidateIntegerField
- VectorParsing: ValidateAnimationCurveFormat, ValidateQuaternionFormat
Added comprehensive XML documentation clarifying keyframe field defaults
(all default to 0 except as noted).
Added 5 new dry-run validation tests covering valid and invalid formats
for both AnimationCurve and Quaternion properties.
* test: fix integration tests after merge
- test_refresh_unity_retry_recovery: Mock now handles both refresh_unity and
get_editor_state commands (refresh_unity internally calls get_editor_state
when wait_for_ready=True)
- test_run_tests_async_forwards_params: Mock response now includes required
'mode' field for RunTestsStartResponse Pydantic validation
- test_get_test_job_forwards_job_id: Updated to handle GetTestJobResponse as
Pydantic model instead of dict (use model_dump() for assertions)
* Update warning message to apply to all test modes
Follow-up to PR #527: Since SaveDirtyScenesIfNeeded() now runs for all test modes, update the warning message to say 'tests' instead of 'PlayMode tests'.
* feat(run_tests): add wait_timeout to get_test_job to avoid client loop detection
When polling for test completion, MCP clients like Cursor can detect the
repeated get_test_job calls as 'looping' and terminate the agent.
Added wait_timeout parameter that makes the server wait internally for tests
to complete (polling Unity every 2s) before returning. This dramatically
reduces client-side tool calls from 10-20 down to 1-2, avoiding loop detection.
Usage: get_test_job(job_id='xxx', wait_timeout=30)
- Returns immediately if tests complete within timeout
- Returns current status if timeout expires (client can call again)
- Recommended: 30-60 seconds
* fix: use Pydantic attribute access in test_run_tests_async for merge compatibility
* revert: remove local test harness - will be submitted in separate PR
* fix: stdio transport survives test runs without UI flicker
Root cause: WriteToConfigTests.TearDown() was unconditionally deleting
UseHttpTransport EditorPref even when tests were skipped on Windows
(NUnit runs TearDown even after Assert.Ignore).
Changes:
- Fix WriteToConfigTests to save/restore prefs instead of deleting
- Add centralized ShouldForceUvxRefresh() for local dev path detection
- Clean stale Python build/ artifacts before client configuration
- Improve reload handler flag management to prevent stuck Resuming state
- Show Resuming status during stdio bridge restart
- Initialize client config display on window open
- Add DevModeForceServerRefresh to EditorPrefs window known types
---------
Co-authored-by: Marcus Sanatan <msanatan@gmail.com>
Co-authored-by: Scott Jennings <scott.jennings+CIGINT@cloudimperiumgames.com>
* Remove stray .meta file
* Add a new project that will do asset uploads
* Add asset store uploader
* refactor: Replace Debug.Log calls with McpLog helper across codebase
Standardize logging by replacing direct Debug.Log/LogWarning/LogError calls
with McpLog.Info/Warn/Error throughout helper classes and client registry.
Affected files:
- McpClientRegistry.cs
- GameObjectLookup.cs
- GameObjectSerializer.cs
- MaterialOps.cs
- McpConfigurationHelper.cs
- ObjectResolver.cs
- PropertyConversion.cs
- UnityJsonSerializer.cs
- UnityTypeResolver.cs
* feat: Add Asset Store release preparation script
Add prepare_unity_asset_store_release.py tool to automate Asset Store packaging:
- Stages temporary copy of MCPForUnity with Asset Store-specific edits
- Removes auto-popup setup window ([InitializeOnLoad] attribute)
- Renames menu entry to "Local Setup Window" for clarity
- Sets default HTTP base URL to hosted endpoint
- Defaults transport to HTTPRemote instead of HTTPLocal
- Supports dry-run mode and optional backup of existing Assets/MCPForUnity
* Show gif of MCP for Unity in Action
* Add shield with asset store link
* Update README to have asset store page unders installation section
* feat: Redesign GameObject API for better LLM ergonomics
- find_gameobjects: Search GameObjects, returns paginated instance IDs only
- manage_components: Component lifecycle (add, remove, set_property)
- unity://scene/gameobject/{id}: Single GameObject data (no component serialization)
- unity://scene/gameobject/{id}/components: All components (paginated)
- unity://scene/gameobject/{id}/component/{name}: Single component by type
- manage_scene get_hierarchy: Now includes componentTypes array
- manage_gameobject: Slimmed to lifecycle only (create, modify, delete)
- Legacy actions (find, get_components, etc.) log deprecation warnings
- ParamCoercion: Centralized int/bool/float/string coercion
- VectorParsing: Vector3/Vector2/Quaternion/Color parsing
- GameObjectLookup: Centralized GameObject search logic
- 76 new Unity EditMode tests for ManageGameObject actions
- 21 new pytest tests for Python tools/resources
- New NL/T CI suite for GameObject API (GO-0 to GO-5)
Addresses LLM confusion with parameter overload by splitting into
focused tools and read-only resources.
* feat: Add GameObject API stress tests and NL/T suite updates
Stress Tests (12 new tests):
- BulkCreate small/medium batches
- FindGameObjects pagination with by_component search
- AddComponents to single object
- GetComponents with full serialization
- SetComponentProperties (complex Rigidbody)
- Deep hierarchy creation and path lookup
- GetHierarchy with large scenes
- Resource read performance tests
- RapidFire create-modify-delete cycles
NL/T Suite Updates:
- Added GO-0..GO-10 tests in nl-gameobject-suite.md
- Fixed tool naming: mcp__unity__ → mcp__UnityMCP__
Other:
- Fixed LongUnityScriptClaudeTest.cs compilation errors
- Added reports/, .claude/local/, scripts/local-test/ to .gitignore
All 254 EditMode tests pass (250 run, 4 explicit skips)
* fix: Address code review feedback
- ParamCoercion: Use CultureInfo.InvariantCulture for float parsing
- ManageComponents: Move Transform removal check before GetComponent
- ManageGameObjectFindTests: Use try-finally for LogAssert.ignoreFailingMessages
- VectorParsing: Document that quaternions are not auto-normalized
- gameobject.py: Prefix unused ctx parameter with underscore
* fix: Address more code review feedback
NL/T Prompt Fixes:
- nl-gameobject-suite.md: Remove non-existent list_resources/read_resource from AllowedTools
- nl-gameobject-suite.md: Fix parameter names (component_type, properties)
- nl-unity-suite-nl.md: Remove unused manage_editor from AllowedTools
Test Fixes:
- GameObjectAPIStressTests: Add null check to ToJObject helper
- GameObjectAPIStressTests: Clarify AudioSource usage comment
- ManageGameObjectFindTests: Use built-in 'UI' layer instead of 'Water'
- LongUnityScriptClaudeTest: Clean up NL/T test artifacts (Counte42 typo, HasTarget)
* docs: update README tools and resources lists
- Add missing tools: manage_components, batch_execute, find_gameobjects, refresh_unity
- Add missing resources: gameobject_api, editor_state_v2
- Make descriptions more concise across all tools and resources
- Ensure documentation matches current MCP server functionality
* chore: Remove accidentally committed test artifacts
- Remove Materials folder (40 .mat files from interactive testing)
- Remove Shaders folder (5 noise shaders from testing)
- Remove test scripts (Bounce*, CylinderBounce* from testing)
- Remove Temp.meta and commit.sh
* refactor: remove deprecated manage_gameobject actions
- Remove deprecated switch cases: find, get_components, get_component, add_component, remove_component, set_component_property
- Remove deprecated wrapper methods (423 lines deleted from ManageGameObject.cs)
- Delete ManageGameObjectFindTests.cs (tests deprecated 'find' action)
- Remove deprecated test methods from ManageGameObjectTests.cs
- Add GameObject resource URIs to README documentation
- Add batch_execute performance tips to README, tool description, and gameobject_api resource
- Enhance batch_execute description to emphasize 10-100x performance gains
Total: ~1200 lines removed. New API (find_gameobjects, manage_components, resources) is the recommended path forward.
* refactor: consolidate shared services across MCP tools
Major architectural improvements:
- Create UnityJsonSerializer for shared JSON/Unity type conversion
- Create ObjectResolver for unified object resolution (GameObjects, Components, Assets)
- Create UnityTypeResolver for consolidated type resolution with caching
- Create PropertyConversion for unified JSON→Unity property conversion
- Create ComponentOps for low-level component operations
- Create Pagination helpers for standardized pagination across tools
Tool simplifications:
- ManageGameObject: Remove 68-line prefab redirect anti-pattern, delegate to helpers
- ManageAsset: Remove ~80 lines duplicate ConvertJTokenToType
- ManageScriptableObject: Remove ~40 lines duplicate ResolveType
- ManageComponents: Use ComponentOps, UnityTypeResolver (~90 lines saved)
- ManageMaterial: Standardize to SuccessResponse/ErrorResponse patterns
- FindGameObjects: Use PaginationRequest/PaginationResponse
- GameObjectLookup: FindComponentType delegates to UnityTypeResolver
Tests: 242/246 passed, 4 skipped (expected)
* Apply code review feedback: consolidate utilities and improve compatibility
Python Server:
- Extract normalize_properties() to shared utils.py (removes duplication)
- Move search_term validation before preflight() for fail-fast
- Fix manage_script.py documentation (remove incorrect 'update' reference)
- Remove stale comments in execute_menu_item.py, manage_editor.py
- Remove misleading destructiveHint from manage_shader.py
C# Unity:
- Add Vector4Converter (commonly used, was missing)
- Fix Unity 2021 compatibility: replace FindObjectsByType with FindObjectsOfType
- Add path normalization in ObjectResolver before StartsWith check
- Improve ComponentOps.SetProperty conversion error detection
- Add Undo.RecordObject in ManageComponents before property modifications
- Improve error message clarity in ManageMaterial.cs
- Add defensive error handling to stress test ToJObject helper
- Increase CI timeout thresholds for test stability
GitHub Workflows:
- Fix GO test sorting in markdown output (GO-10 now sorts after GO-9)
- Add warning logging for fragment parsing errors
* Fix animator hash names in test fixture to match parameter names
BlendXHash/BlendYHash now use 'reachX'/'reachY' to match the
actual animator parameter names.
* fix(windows): improve HTTP server detection and auto-start reliability
- Fix netstat detection on Windows by running netstat.exe directly instead
of piping through findstr (findstr returns exit code 1 when no matches,
causing false detection failures)
- Increase auto-start retry attempts (20→30) and delays (2s→3s) to handle
slow server starts during first install, version upgrades, and dev mode
- Only attempt blind connection after 20 failed detection attempts to reduce
connection error spam during server startup
- Remove verbose debug logs that were spamming the console every frame
* fix: auto-create tags and remove deprecated manage_gameobject actions
- ManageGameObject.cs: Check tag existence before setting; auto-create
undefined tags using InternalEditorUtility.AddTag() instead of relying
on exception handling (Unity logs warning, doesn't throw)
- manage_gameobject.py: Remove deprecated actions (find, get_components,
add_component, remove_component, set_component_property, get_component)
from Literal type - these are now handled by find_gameobjects and
manage_components tools
- Update test suite and unit tests to reflect new auto-create behavior
* fix: address code review feedback
Bug fixes:
- Fix searchInactive flag ignored in FindObjectsOfType (use includeInactive overload)
- Fix property lookup to try both original and normalized names for backwards compat
- Remove dead code for deprecated 'find' action validation
- Update error message to list only valid actions
Improvements:
- Add destructiveHint=True to manage_shader tool
- Limit fallback connection attempts (every 3rd attempt) to avoid spamming errors
- Consolidate PropertyConversion exception handlers to single catch block
- Add tag existence assertion and cleanup in tag auto-creation tests
Test fixes:
- Update SetComponentProperties_ContinuesAfterException log regex for new error format
- Update test_manage_gameobject_param_coercion to test valid actions only
* fix: Multi-session UI improvements and HTTP instance recognition
- Separate server and session lifecycle in HTTP Local mode
- Show 'Start Server' / 'Stop Server' button for server control
- Show 'Start Session' / 'End Session' button when server is running
- No auto-join on server start (requires manual session start)
- Show instance name instead of port in session status (e.g. 'Session Active (ramble)')
- Use native project_hash for HTTP instance recognition instead of computed SHA256
- Fix test expectations for manage_asset JSON parsing error messages
* fix: Multi-session UI improvements and HTTP instance recognition
- Separate server and session lifecycle in HTTP Local mode
- Show 'Start Server' / 'Stop Server' button for server control
- Show 'Start Session' / 'End Session' button when server is running
- Auto-start session when THIS instance starts the server
- Require manual session start when connecting to external server
- Auto-detect and end orphaned sessions when server stops
- Show instance name instead of port in session status
- Use native project_hash for HTTP instance recognition
- Guard against empty hash with warning log
- Remove dead code (duplicate _safe_response)
- Add defensive path handling for instance name extraction
* Add editor readiness v2, refresh tool, and preflight guards
* Detect external package changes and harden refresh retry
* feat: add TestRunnerNoThrottle and async test running with background stall prevention
- Add TestRunnerNoThrottle.cs: Sets editor to 'No Throttling' mode during test runs
with SessionState persistence across domain reload
- Add run_tests_async and get_test_job tools for non-blocking test execution
- Add TestJobManager for async test job tracking with progress monitoring
- Add ForceSynchronousImport to all AssetDatabase.Refresh() calls to prevent stalls
- Mark DomainReloadResilienceTests as [Explicit] with documentation explaining
the test infrastructure limitation (internal coroutine waits vs MCP socket polling)
- MCP workflow is unaffected - socket messages provide external stimulus that
keeps Unity responsive even when backgrounded
* refactor: simplify and clean up code
- Remove unused Newtonsoft.Json.Linq import from TestJobManager
- Add throttling to SessionState persistence (once per second) to reduce overhead
- Critical job state changes (start/finish) still persist immediately
- Fix duplicate XML summary tag in DomainReloadResilienceTests
* docs: add async test tools to README, document domain reload limitation
- Add run_tests_async and get_test_job to main README tools list
- Document background stall limitation for domain reload tests in DEV readme
* ci: add separate job for domain reload tests
Run [Explicit] domain_reload tests in their own job using -testCategory
* ci: run domain reload tests in same job as regular tests
Combines into single job with two test steps to reuse cached Library
* fix: address coderabbit review issues
- Fix TOCTOU race in TestJobManager.StartJob (single lock scope for check-and-set)
- Store TestRunnerApi reference with HideAndDontSave to prevent GC/serialization issues
* docs: update tool descriptions to prefer run_tests_async
- run_tests_async is now marked as preferred for long-running suites
- run_tests description notes it blocks and suggests async alternative
* docs: update README screenshot to v8.6 UI
* docs: add v8.6 UI screenshot
* Update README for MCP version and instructions for v8.7
* fix: handle preflight busy signals and derive job status from test results
- manage_asset, manage_gameobject, manage_scene now check preflight return
value and propagate busy/retry signals to clients (fixes Sourcery #1)
- TestJobManager.FinalizeCurrentJobFromRunFinished now sets job status to
Failed when resultPayload.Failed > 0, not always Succeeded (fixes Sourcery #2)
* fix: increase HTTP server startup timeout for dev mode
When 'Force fresh server install' is enabled, uvx uses --no-cache --refresh
which rebuilds the package and takes significantly longer to start.
- Increase timeout from 10s to 45s when dev mode is enabled
- Add informative log message explaining the longer startup time
- Show actual timeout value in warning message
* fix: derive job status from test results in FinalizeFromTask fallback
Apply same logic as FinalizeCurrentJobFromRunFinished: check result.Failed > 0
to correctly mark jobs as Failed when tests fail, even in the fallback path
when RunFinished callback is not delivered.
* Avoid blocking Claude CLI status checks on focus
* Fix Claude Code registration to remove existing server before re-registering
When registering with Claude Code, if a UnityMCP server already exists,
remove it first before adding the new registration. This ensures the
transport mode (HTTP vs stdio) is always updated to match the current
UseHttpTransport EditorPref setting.
Previously, if a stdio registration existed and the user tried to register
with HTTP, the command would fail with 'already exists' and the old stdio
configuration would remain unchanged.
* Fix Claude Code transport validation to parse CLI output format correctly
The validation code was incorrectly parsing the output of 'claude mcp get UnityMCP' by looking for JSON format ("transport": "http"), but the CLI actually returns human-readable text format ("Type: http"). This caused the transport mismatch detection to never trigger, allowing stdio to be selected in the UI while HTTP was registered with Claude Code.
Changes:
- Fix parsing logic to check for "Type: http" or "Type: stdio" in CLI output
- Add OnTransportChanged event to refresh client status when transport changes
- Wire up event handler to trigger client status refresh on transport dropdown change
This ensures that when the transport mode in Unity doesn't match what's registered with Claude Code, the UI will correctly show an error status with instructions to re-register.
* Fix Claude Code registration UI blocking and thread safety issues
This commit resolves three issues with Claude Code registration:
1. UI blocking: Removed synchronous CheckStatus() call after registration
that was blocking the editor. Status is now set immediately with async
verification happening in the background.
2. Thread safety: Fixed "can only be called from the main thread" errors
by capturing Application.dataPath and EditorPrefs.GetBool() on the main
thread before spawning async status check tasks.
3. Transport mismatch detection: Transport mode changes now trigger immediate
status checks to detect HTTP/stdio mismatches, instead of waiting for the
45-second refresh interval.
The registration button now turns green immediately after successful
registration without blocking, and properly detects transport mismatches
when switching between HTTP and stdio modes.
* Enforce thread safety for Claude Code status checks at compile time
Address code review feedback by making CheckStatusWithProjectDir thread-safe
by design rather than by convention:
1. Made projectDir and useHttpTransport parameters non-nullable to prevent
accidental background thread calls without captured values
2. Removed nullable fallback to EditorPrefs.GetBool() which would cause
thread safety violations if called from background threads
3. Added ArgumentNullException for null projectDir instead of falling back
to Application.dataPath (which is main-thread only)
4. Added XML documentation clearly stating threading contracts:
- CheckStatus() must be called from main thread
- CheckStatusWithProjectDir() is safe for background threads
5. Removed unreachable else branch in async status check code
These changes make it impossible to misuse the API from background threads,
with compile-time enforcement instead of runtime errors.
* Consolidate local HTTP Start/Stop and auto-start session
* HTTP improvements: Unity-owned server lifecycle + UI polish
* Deterministic HTTP stop via pidfile+token; spawn server in terminal
* Fix review feedback: token validation, host normalization, safer casts
* Fix stop heuristics edge cases; remove dead pid capture
* Fix unity substring guard in stop heuristics
* Fix local server cleanup and connection checks
* Fix read_console default limits; cleanup Unity-managed server vestiges
* Fix unfocused reconnect stalls; fast-fail retryable Unity commands
* Simplify PluginHub reload handling; honor run_tests timeout
* Fix Windows Claude CLI status check threading
* Fix macOS port conflict: Disable SO_REUSEADDR and improve UI port display
- StdioBridgeHost.cs: Disable ReuseAddress on macOS to force AddressAlreadyInUse exception on conflict.
- PortManager.cs: Add connection check safety net for macOS.
- McpConnectionSection.cs: Ensure UI displays the actual live port instead of just the requested one.
* Fix macOS port conflict: Disable SO_REUSEADDR and improve UI port display
- StdioBridgeHost.cs: Disable ReuseAddress on macOS to force AddressAlreadyInUse exception on conflict.
- PortManager.cs: Add connection check safety net for macOS.
- McpConnectionSection.cs: Ensure UI displays the actual live port instead of just the requested one.
* Address CodeRabbit feedback: UX improvements and code quality fixes
- McpConnectionSection.cs: Disable port field when session is running to prevent editing conflicts
- StdioBridgeHost.cs: Refactor listener creation into helper method and update EditorPrefs on port fallback
- unity_instance_middleware.py: Narrow exception handling and preserve SystemExit/KeyboardInterrupt
- debug_request_context.py: Document that debug fields expose internal implementation details
* Fix: Harden Python detection on Windows to handle App Execution Aliases
* Refactor: Pre-resolve conflicts for McpConnectionSection and middleware
* Fix: Remove leftover merge conflict markers in StdioBridgeHost.cs
* fix: clarify create_script tool description regarding base64 encoding
* fix: improve python detection on macOS by checking specific Homebrew paths
* Fix duplicate SetEnabled call and improve macOS Python detection
* Fix port display not reverting to saved preference when session ends
* 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>
Marcus Sanatan
Alex Hvesuk
dsarno