`) you can fetch via `GetSkills` for deeper detail Always call `discover_python_class` on the classes in `vibeue_classes` before writing code â€” never guess method names from the skill content alone. **Batch the discovery into ONE call** instead of one call per class: ``` # ONE call covers all classes and all topics: discover_python_class( class_name="unreal.MaterialService, unreal.WidgetService, unreal.MaterialNodeService", method_filter="create|delete|compile|property|color") # WRONG â€” three separate calls for three classes wastes round-trips and repeats boilerplate ``` `class_name` accepts a comma-separated list (response gains a `classes` array, one entry per class); `method_filter` ORs keywords with `|`. ## How work gets done â€” `execute_python_code` is the workhorse VibeUE services are plain Python on the editor's `unreal` module. Run everything through `execute_python_code`: ```python import unreal widgets = unreal.WidgetService.list_widget_blueprints() unreal.StateTreeService.create_state_tree("/Game/AI/MyBehavior") ``` You get the full `unreal.*` API plus every `unreal.` VibeUE adds. Reserve `call_tool` for **engine toolsets and skills** (e.g. `AgentSkillToolset`, `EditorToolset.EditorAppToolset`, `LogsToolset`, `GameplayTagsToolset`, `AssetTools`). **`code` is Python source, never a script path.** A path such as `C:/scripts/build.py` passed as `code` is compiled as Python and fails (`SyntaxError` / `NameError`); it is not run as a file. (Code that merely mentions a `.py` file in a comment or string runs normally.) To run a script file, pass code that runs it: ```python import unreal, runpy runpy.run_path(r"C:/scripts/build.py") # the script gets its own globals # or, sharing the console globals every execute_python_code call sees: exec(open(r"C:/scripts/build.py").read()) ``` **`auto_save` (default true).** Before running your script, `execute_python_code` saves every dirty content AND world package headlessly (issue #433: this avoids the modal save dialog that would hang the call). Every reply reports what actually happened: `auto_save` (true only when the sweep really ran), `auto_save_note` (empty when it ran, otherwise `opted_out`, `previous_run_crashed`, `editor_unavailable`, `pie_active`, or `save_failed`) and `saved_packages` (the package names it wrote). `auto_save` is the OUTCOME, not an echo of your argument -- so `auto_save: true, saved_packages: []` means "swept, nothing was dirty", never "skipped". Pass `auto_save=false` to run the script WITHOUT that sweep -- use it when you do not want in-flight editor edits flushed to disk, or to keep a mutation you are about to make from being interleaved with an unrelated dirty package. The sweep is skipped anyway after a crashed run, when GEditor is missing, or in PIE. ## Never leave a map loaded - it crashes the editor on the next level change Opening a map as an **asset** keeps it resident: ```python w = unreal.load_asset("/Game/Maps/Foo") # loads and KEEPS Foo unreal.EditorAssetLibrary.load_asset("/Game/Maps/Foo") unreal.find_object(None, "/Game/Maps/Foo.Foo") ``` The engine checks on every level load that no other map package is still alive. That check is a **fatal, not a warning** - the editor dies with `World Memory Leaks` (`EditorServer.cpp`) and `Old level package /Game/Maps/Foo not cleaned up by garbage collection`. The crash lands on whoever calls `load_level` next, which may be minutes later and a different tool entirely, and the message names neither the script nor the map that caused it. `execute_python_code` reports this in every reply so the warning arrives with its cause: ```json "resident_maps": ["/Game/Maps/Foo.Foo"] ``` **Non-empty `resident_maps` means the next level load will crash the editor.** There is no reliable in-process cure. A map package loads with `RF_Standalone`, and **neither `unreal.SystemLibrary.collect_garbage()` nor `EditorLoadingAndSavingUtils.unload_packages()` releases it** - both were tried against a live editor and the world stayed resident. Once a map is stranded, **restart the editor** (`BuildAndLaunchGame.ps1`) before changing levels. So treat this as prevention, not repair: - To read a map's **metadata**, use the asset registry - it loads nothing: ```python ar = unreal.AssetRegistryHelpers.get_asset_registry() maps = ar.get_assets_by_path("/Game/Maps", recursive=True) ``` - To **change level**, use `unreal.get_editor_subsystem(unreal.LevelEditorSubsystem).load_level(path)`, which swaps the open world properly. Never `load_asset` a map to "look at it". The open level is never reported - only stragglers. ## Tools â€” what each is for | Tool | Use it for | |------|-----------| | `execute_python_code` | Run `unreal.*` Python in the editor â€” the workhorse for every VibeUE service | | `call_tool` | Invoke engine toolsets and skills (skills, PIE control, logs, assets, gameplay tags) | | `describe_toolset` / `list_toolsets` | Discover engine toolsets and their actions/args | | `discover_python_class` / `discover_python_function` / `discover_python_module` | Get live signatures before writing code | | `list_python_subsystems` | Enumerate editor subsystems for `unreal.get_editor_subsystem(...)` | | `terrain_data` | Real-world heightmaps + water splines (see `terrain-data` skill) | | `deep_research` | Web research / page fetch / geocoding. If Jina Reader refuses your network (HTTP 401), set a free Jina key in the `JINA_API_KEY` environment variable and restart the editor | `deep_research` and `terrain_data` run off the game thread, so the editor keeps working while they wait. Four run at a time and more wait their turn; past 16 running or waiting, a call is refused with `BUSY` (retry when one finishes). Cancelling one from the client (`notifications/cancelled`) matches it by JSON-RPC request id only: with several MCP clients connected, a cancel can also end another client's call that carries the same id. ## Engine toolsets replace the old VibeUE tools Several capabilities that used to be VibeUE-specific MCP tools are now the engine's native toolsets, called via `call_tool` (run `describe_toolset` for action names/params): | Need | Engine toolset (via `call_tool`) | |------|----------------------------------| | Start / stop / query PIE | `EditorToolset.EditorAppToolset` â†’ `StartPIE` / `StopPIE` / `IsPIERunning` | | Capture a viewport screenshot | `EditorToolset.EditorAppToolset` â†’ `CaptureViewport` | | List / read / filter / tail UE logs | `LogsToolset` | | Search / open / save / move / import assets | `AssetTools` | | Single-tag gameplay-tag CRUD | `GameplayTagsToolset` (see `gameplay-tags` skill) | | Inspect a live Ability System (attributes/tags/effects/abilities), attribute-set discovery, gameplay cues | `GASToolsets.*` (see `gas` skill) | Performance/Insights tracing is the one net-new VibeUE service â€” `unreal.PerformanceService.*` (see the `profiling` skill) â€” because Unreal 5.8 ships no performance toolset. ## Additional gotchas - A Python traceback still proves the MCP link is up — only "Unable to connect" means it is down. A dropped server or a newly added tool needs a Claude Code restart. A stuck call is usually a modal dialog and the client timeout does not stop the script, so persisted results (`vibeue.last_python_result()`) let you read the outcome on the next call rather than re-running. - Don't run a headless `UnrealEditor-Cmd` while the GUI editor is starting — they fight over the MCP port and the loser runs with no MCP; the readiness signal's `mcpListening` flag tells you when the port is claimed. `-run=pythonscript` fully substitutes for pure-asset work when no editor runs, but not for World Partition world surgery. - Engine toolset quirks: `LogsToolset.GetLogEntries` requires a `pattern`; `StartPIE` via `execute_tool` needs the full options object; results can be double-encoded (`vibeue.exec_tool` decodes them). A genuinely async tool like `CaptureAssetImage` never completes inside one call — fire it with `vibeue.exec_tool_async` and read it with `vibeue.collect_tool_result` on the next call. - A leaked `register_slate_post_tick_callback` can survive its own unregister; an editor restart is the only reliable purge.