@uemcp/server 1.10.0 → 1.12.0

package/README.md

@@ -64,6 +64,7 @@ The MCP tool surface currently exposes:
 - `disconnect_pins`
 - `set_pin_default`
 - `list_available_nodes`
+- `layout_graph`
 - `set_viewport_camera`
 - `focus_actors`
 - `set_view_mode`
@@ -131,6 +132,22 @@ The MCP tool surface currently exposes:
 - `scaffold_class_template`
 - `get_live_compile_details`
 - `run_editor_python`
+- `set_navmesh_settings`
+- `set_nav_agents`
+- `set_crowd_settings`
+- `create_nav_area`
+- `add_nav_modifier_volume`
+- `add_nav_link`
+- `find_path`
+- `test_reachability`
+- `create_smart_object_definition`
+- `get_smart_object_definition`
+- `add_smart_object_component`
+- `create_mass_entity_config`
+- `edit_mass_entity_config`
+- `get_mass_entity_config`
+- `validate_mass_entity_config`
+- `diagnose_navmesh`
 
 ## Project Identity
 
@@ -338,7 +355,7 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - `create_folder` reports `state: 'exists'` rather than failing when the folder is already there, since that is the state the caller wanted. A content folder is an Asset Registry entry until something is saved into it, so an empty one does not survive an editor restart — the response says so
 - `get_asset_metadata` answers from the Asset Registry's `FAssetData` and **never loads the package**: class, package name and path, on-disk size, and the registry tag map — which carries a Blueprint's parent class, a texture's dimensions, a DataTable's row struct. `loaded` reports whether it happens to be in memory already; `false` is normal
 
-### `list_graph_nodes` / `add_graph_node` / `remove_graph_node` / `connect_pins` / `disconnect_pins` / `set_pin_default` / `list_available_nodes`
+### `list_graph_nodes` / `add_graph_node` / `remove_graph_node` / `connect_pins` / `disconnect_pins` / `set_pin_default` / `list_available_nodes` / `layout_graph`
 
 - Blueprint graph authoring. `get_blueprint_graph` reads a graph; these write to one, and they work on any `UEdGraph` — an event graph or function, an Animation Blueprint AnimGraph, a Material graph
 - **Nodes are addressed by GUID, never by index.** A graph's node array reorders on every edit and recompile, so an index read a moment ago can name a different node by the time it is written back. `nodeId` from `list_graph_nodes` is what every other tool here takes. `list_graph_nodes` is the only read here, so it is the only one that takes `loadIfNeeded`; the write tools need the asset in memory regardless
@@ -346,6 +363,8 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - `connect_pins` asks the schema's `CanCreateConnection` before connecting, so an illegal wire comes back with **the schema's own refusal text** rather than a generic failure after the fact
 - `set_pin_default` refuses an output pin and a pin that is already connected — a connected pin takes its value from the wire, so a literal there would be stored and then ignored. The stored value is validated after the write and the previous literal restored if the schema rejects it
 - `list_available_nodes` answers from `FBlueprintActionDatabase` filtered by this graph's context, so what it lists is what the graph would actually accept rather than every node class the editor knows about
+- `layout_graph` arranges a Blueprint graph so **no two nodes overlap**: exec flow is layered left to right from each event, a branch fans its successors out downward, and pure nodes sit in the column left of the node that consumes them. Comment boxes are left where they are. It is **one undo step**. Node sizes are estimated from the title and pin labels, because the rendered size belongs to a Slate widget that exists only while the graph is open in an editor tab
+- `add_graph_node` with `autoLayout` moves **only the new node**: from `position` it slides down until it overlaps nothing, and with no `position` it starts just right of the existing nodes. The response reports where it landed. Relaying out the whole graph on every add would move nodes the caller already reasoned about
 - Every edit marks the Blueprint structurally modified and leaves it **dirty and uncompiled** — compose with `compile_blueprint` and `save_asset`
 
 ### `set_viewport_camera` / `focus_actors` / `set_view_mode` / `toggle_show_flags` / `high_res_screenshot`
@@ -661,6 +680,49 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - An editor whose Python Script Plugin is absent or disabled returns `state: 'unsupported'` with the reason, which is a different answer from a script that ran and failed
 - The whole script runs inside one `FScopedTransaction`, so a successful run is a single editor undo; a failed run cancels the transaction rather than leaving half its effects behind
 - `executionMode` is `script` (default: a whole block of Python, or a `.py` path with arguments), `statement` (exactly one statement) or `evaluate` (one expression, whose value comes back in `result`). `script` is the default because the engine reports a traceback line by line only in that mode; the two statement modes put it in `result` instead. Commands are capped at 16,384 characters, and output and error lines at 200 lines each, with `truncated` set
+### `set_navmesh_settings` / `set_nav_agents` / `set_crowd_settings`
+
+- Navmesh generation settings are written onto the level's `RecastNavMesh` actor and only reach the navmesh on the next build, so the response reports `rebuildRequired` and the caller follows with `build_navigation`. Rebuilding here instead would be a minutes-long job on a socket with a seconds-long read budget
+- `cellSize`, `cellHeight` and `agentMaxStepHeight` live per resolution since UE 5.4 — the same-named members on the actor are deprecated and no longer read by the generator — so `resolution` names which of the three sets is being written, and `appliedSettings` reports exactly which fields the write touched
+- The response reports every setting as it stands **after** the write, read back off the actor, so a value the navmesh clamped is visible rather than echoed back as requested
+- `set_nav_agents` replaces the project's whole `SupportedAgents` list, which is what gives a level one navmesh per agent size. It is read once when the navigation system starts, so the response reports `restartRequired` rather than pretending a running editor picked it up
+- `set_crowd_settings` writes the Detour crowd manager and the RVO avoidance manager, both config defaults rather than per-level state. Only the manager a request actually names is saved, so a crowd-only call leaves the avoidance section alone
+
+### `create_nav_area` / `add_nav_modifier_volume` / `add_nav_link`
+
+- `create_nav_area` makes a nav area Blueprint under `NavArea` (or one of the stock parents) and reports `generatedClassPath` — the class, not the asset, is what a modifier volume or a link references
+- `add_nav_modifier_volume` places an `ANavModifierVolume` and builds its cube brush through the same actor factory the place-actor panel uses. Without that brush the volume covers nothing, so a non-positive extent is refused rather than placed
+- `add_nav_link` replaces the proxy's default link with the ones the request carries. `left` and `right` are offsets from the actor, the space the level editor's own link handles move in, and the response reports them in world space so a link and the `find_path` that crosses it can be compared directly
+- All three leave the navmesh untouched until the next `build_navigation`, and say so through `rebuildRequired`
+
+### `find_path` / `test_reachability`
+
+- Synchronous navmesh queries against the editor world, which is what makes "is this level traversable" answerable without entering PIE
+- A destination nothing can reach comes back as `reachable: false` with a partial path, not as an error: that is the answer, and a tool that threw would make the check unusable in a sweep. `queryResult` carries the engine's own `ENavigationQueryResult` so an off-navmesh endpoint stays distinguishable from a walled-off one
+- `reachable` means a path that actually arrives. A partial path proves the goal is **not** reachable however far along it got, so it never counts as reachable in `find_path`
+- `test_reachability` answers a batch of pairs without returning path geometry, and fails one pair rather than the request when an actor path no longer resolves — a sweep of spawn points against objectives is worth answering for the pairs that did resolve
+
+### `create_smart_object_definition` / `get_smart_object_definition` / `add_smart_object_component`
+
+- Backed by the SmartObjects engine plugin, which MCPBridge enables. When its module is not loaded the three tools answer `state: 'unsupported'` with the reason instead of failing
+- A definition is created with its slots in one call: offset and rotation relative to the owning actor, activity tags, an enabled flag and behavior definitions (instanced `USmartObjectBehaviorDefinition` subclasses configured through `params`). Activity tags must already be registered; a definition missing one is refused and nothing is left behind
+- Both the create and the read report `valid` and the engine's `validationMessages`. The Smart Object subsystem refuses to register a component whose definition fails validation, most often a slot with no behavior definition and no default, so `valid: false` means nothing can ever claim it
+- `add_smart_object_component` takes exactly one of `blueprintPath` (the Blueprint is recompiled) or `actorPath` (a placed actor in the editor level). An existing Smart Object component is pointed at the new definition rather than joined by a second, because an actor carrying two registers as two objects; `created` says which happened. The component registers with the subsystem when play begins
+
+### `create_mass_entity_config` / `edit_mass_entity_config` / `get_mass_entity_config` / `validate_mass_entity_config`
+
+- Author a `UMassEntityConfigAsset`, the trait list a Mass agent is spawned from. `create_mass_entity_config` takes an optional `parentConfigPath`; a trait the child owns overrides the parent's trait of the same class
+- `edit_mass_entity_config` applies `add`, `remove` and `set` edits in order and reports each one. Traits are named by class (`MassMovementTrait`, `MassLODCollectorTrait`, `MassVisualizationTrait`, `MassStateTreeTrait`, or a `/Script/Module.Class` path), and properties are `{ propertyPath, value }` pairs in exported-text form, the same shape `set_asset_property` takes. Only the config's own traits are edited, never a parent's. A new trait whose properties are rejected is taken back out
+- `get_mass_entity_config` reads the parent and each own trait with its editable properties as exported text, trimmed by encoded size with `truncated` set
+- `validate_mass_entity_config` builds the entity template in the editor world, the way the asset editor's Validate button does, and returns the engine's own error and warning lines verbatim in `messages`
+- Every tool returns `state: 'unsupported'` with a reason when the Mass runtime is not loaded (MCPBridge enables `MassGameplay` and `MassAI`), and validation does the same when the editor world has no Mass entity subsystem
+
+### `diagnose_navmesh`
+
+- A read-only audit of the editor level's navmesh: missing `NavMeshBoundsVolume`s, no navigation data or an empty navmesh, disconnected islands, and spawn points that are off the navmesh or cannot path to the first one. Each finding lands in `issues` with a `code`, and `healthy` is true when there are none. Nothing is rebuilt or fixed
+- Islands are the connected components of the Recast polygon graph, nav links included, listed largest walkable area first with poly count, area and bounds. One-way links still join two areas, so a drop-down ledge is not reported as a stray island. `islandCount` stays the full count when `maxIslands` cuts the list
+- Every `PlayerStart` is checked by default; AI spawners have no common base class, so a level's own spawn actors are named in `spawnActorPaths`. Player starts come first, and the first spawn on the navmesh is the anchor every other spawn is path-tested against with the same query `find_path` runs. Spawns on different islands are reported unreachable from the island map without a search
+- An island no spawn point stands on is reported as `island_without_spawn`: the isolated platform an AI can be placed on but never walk off. A level with no navmesh at all reports that once rather than blaming every spawn point for it
 
 ## MCP Resources