Set the active Godot editor session for subsequent tool calls.

Accepts either an exact session_id or a substring hint matched against the session's short name (project folder basename), project_path, or session_id. An exact id match always wins; a substring must resolve to exactly one session or the tool returns an error listing the candidates.

Lightweight readiness probe echoing engine status, version, and memory metrics.

Verifies the end-to-end MCP communication path between the AI agent, the local MCP server, and the active Godot Editor session.

Session listing.

Resource form: godot://sessions — prefer for resource-aware clients.

Ops: • list() List every connected Godot editor with metadata: session_id, short name, godot_version, project_path, plugin_version, server_version, editor_pid, server_launch_mode, current_scene, play_state, readiness, connected_at, last_seen, is_active. The response also carries the server-global exclude_domains (tool domains not registered on this server via --exclude-domains).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Get current Godot editor state: version, readiness, open scene, play state.

Resource form: godot://editor/state — prefer for active-session reads. Also reachable as editor_manage(op="state") (same handler) for clients that prefer a single rolled-up tool.

Code-mode MCP adapters keep the server and tool names separate: call('godot-ai', 'editor_state', {}). Never pass a server-prefixed tool name such as godot-ai/get_editor_state; that is neither the adapter's call signature nor a registered tool. For dedicated current- scene data, use readResource('godot-ai', 'godot://scene/current').

Side effect: refreshes the server's session readiness cache from the live editor reply. Useful as a recovery step after a write call is rejected as EDITOR_NOT_READY (state=playing) when you already know the game has stopped — calling editor_state once syncs the cache and the next write proceeds. Issue #262.

Response includes game_status for authoritative game liveness, plus helper_live (status == "live") and session_active (status not in {"not_live", "stopped"}) mirrored from the same fields inside game_status. is_playing remains raw editor play-state; use game_status.status for liveness decisions. game_status.status="break" means the game process is parked in a remote-debugger break (boot-time parse errors do this before the game helper registers); it will not resume on its own — call project_manage(op="stop").

Read recent log lines from the Godot editor, plugin, or running game.

Resource form: godot://logs/recent — prefer for active-session reads.

Sources:

• "plugin" (default): MCP plugin recv/send/event traffic. Buffer 500.

• "game": stdout/stderr/push_error/push_warning from playing game via _mcp_game_helper autoload. Buffer 2000, with lines retained across runs and tagged by run_id. Default reads return current-run lines only; pass since_run_id from an earlier response to read that prior run. Entries: {source, level, text, run_id}; response carries run_id, current_run_id, game_status, helper_live, session_active, dropped_count, stale_run_id. helper_live and session_active mirror the same fields inside game_status; is_running is retained as a compatibility alias of session_active. Boot-time parse/load errors fire before the game helper's logger attaches, so they are NEVER in this buffer; when editor-side errors were recorded during the current run the response adds editor_errors_count and editor_errors_hint pointing at source="editor" — treat a clean game log carrying that hint as a run that lost scripts, not a clean launch.

• "editor": editor-process script errors and the Debugger dock's visible Errors-tab rows — parse errors, GDScript reload warnings, @tool/EditorPlugin runtime errors, push_error/push_warning. Logger-backed entries and Errors-tab rows are read from the editor UI when available. Use when the editor Output or Debugger Errors panel shows red/yellow rows but other sources turned up nothing. Buffer 500 for logger-backed entries; Debugger rows are live UI state. Entries: {source, level, text, path, line, function}. Filtered to .gd/.cs in the user project for Logger-backed entries; addons/godot_ai/ dropped. Logger entries fired before plugin enable are not captured.

• "all": plugin → editor → game lines (with source per entry).

Tail pattern: for game logs, poll the current run with offset=N and keep the returned run_id. current_run_id identifies the active run; run_id identifies the run being read. Passing since_run_id=old_run_id reads retained lines for that prior run, and stale_run_id: true means the requested run is not the current run. For editor logs, read once to capture next_cursor and pass it back as since_cursor on later calls. since_cursor reads Logger-backed editor entries only; live Debugger Errors-tab rows are included in regular source="editor" reads but do not have stable cursors. When since_cursor is set, it supersedes offset. truncated: true means older entries fell out of the ring before the poll; continue from the returned next_cursor and treat oldest_cursor as the earliest retained sequence. Set include_details=True for Errors-tab style metadata on game/editor entries: original code/rationale, error type, resolved source, and stack frames. Default false preserves compact responses.

Capture a screenshot of the Godot editor viewport or running game.

Picking a source: the default "viewport" captures the editor's 3D viewport, which is empty if the edited scene has no Node3D anywhere in the tree (or no scene is open). Those cases return EDITOR_NOT_READY with error.data = {editor_state: "viewport_not_3d", scene_root_type} and an actionable error.message — switch to "cinematic" if the scene has a Camera3D, or open a scene with 3D content.

Sources:

• "viewport" (default): editor 3D viewport. Requires Node3D content in the edited scene (root or any descendant); see above for the no-3D-content / no-scene error shape.

• "viewport_2d": editor 2D viewport. Use for 2D scenes. Not compatible with view_target/coverage/elevation/azimuth/fov.

• "cinematic": render edited scene through its active Camera3D (no editor gizmos). Prefers a Camera3D marked current; falls back to the first Camera3D found in a depth-first walk. NODE_NOT_FOUND only when the scene contains no Camera3D at all.

• "game": running game's framebuffer (only when project is running). A backgrounded/minimized game window freezes its main loop; the capture then returns the last rendered frame with stale_frame: true and a note in the metadata — focus the game window and retry for a current frame. GAME_HELPER_TIMEOUT means the game process never replied at all (nothing rendered yet, main thread blocked, or helper dead) — focus the window and retry, or use game_command to confirm liveness.

include_image=True (default) returns an MCP ImageContent block. view_target (comma-separated Node3D paths) reframes editor camera; AABB metadata always returned. coverage=True with view_target captures perspective + orthographic top-down references.

Reload the Godot editor plugin.

Disables and re-enables the plugin on the next frame. The response shape depends on whether this MCP server was spawned by the plugin or launched externally:

• Plugin-managed (default install): returns a pre-flight ack {status: "reload_initiated", transport_will_drop: true, old_session_id, guidance} immediately. The reload kills this server, so the WebSocket transport drops; reconnect and call session_manage(op="list") to find the new session_id.

• Externally launched (e.g. python -m godot_ai --transport streamable-http --port 8000 --reload): waits for the new session to register and returns {status: "reloaded", old_session_id, new_session_id}. If the old bridge disappears and no replacement registers within 90 seconds, raises PLUGIN_DISCONNECTED with data.reason == "reload_timeout" and recovery diagnostics.

Editor selection, performance monitors, quit, log clearing, game eval.

Resource forms (prefer for active-session reads): godot://editor/state, godot://selection/current, godot://performance

Ops: • state() Editor version, project name, current scene, readiness, play state. • selection_get() Currently selected node paths in the editor. • selection_set(paths) Replace the selection with the given list of scene paths. • monitors_get(monitors=None) Performance singleton values (FPS, memory, draw calls, etc.). Pass a list of monitor names to filter; None returns everything. • quit() Gracefully quit the Godot editor on next frame. • logs_clear(clear_debugger_errors=False) Clear the MCP log buffer. Returns cleared_count. Pass clear_debugger_errors=True to also clear the Debugger dock's visible Errors-tab rows (user-facing UI, so opt-in only); the response then includes debugger_errors_cleared. • eval(code, mode="auto", inputs={}) Execute arbitrary GDScript directly in the Godot Editor process with full permissions. • execute_script(code="", path="", inputs={}) Execute a script file or inline GDScript code in the Godot Editor process. • game_eval(code) Execute GDScript in the running game with return values. Uses 'await' so user code can await internally. Errors return fast and actionable: EVAL_COMPILE_ERROR for a syntax/parse error, EVAL_RUNTIME_ERROR (with the real message + line) for a runtime error; EVAL_GAME_NOT_READY if the game can't service evals — still launching (retry once it's up), the _mcp_game_helper autoload is missing/disabled, its main loop is not advancing (focus the game), or its debugger session closed; EVAL_HUNG for a live game's genuine infinite loop / never-firing await; EVAL_RESULT_TOO_LARGE if the returned value serializes past the debugger channel's capacity (return a smaller slice).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Get the scene tree hierarchy from the open scene.

Returns a paginated flat list of nodes with name, type, path, and child count. Walks up to the specified depth.

Resource form: godot://scene/hierarchy — prefer for active-session reads.

Open an existing scene file (.tscn) in the editor.

If path is already the currently edited scene this is a no-op — the in-memory state (including any unsaved MCP mutations) is preserved. Pass force_reload=True when the file on disk is the authority and the editor should discard the open in-memory copy and re-read the scene from disk.

The reply is sent only after the editor has actually switched to the requested scene (switched: true), so follow-up writes are safe immediately. switched: false with settle: "timeout" means the switch had not landed within the wait window. In synchronous contexts (e.g. inside batch_execute) the reply returns immediately with switched: false and settle: "not_waited". In both of those cases, re-check editor_state before issuing follow-up writes.

Save the currently edited scene to disk.

Node and property mutation tools change the editor's in-memory scene; call this explicitly to persist those mutations to the existing path.

Scene authoring (create, save_as, list open roots).

Resource form: godot://scene/current and godot://scene/hierarchy — prefer for active-session reads.

Ops: • create(path, root_type="Node3D", root_name="") Create the initial .tscn with the given root and open it. root_name defaults to filename basename when empty. This initial root is written immediately, but later node_create/node_set_property mutations remain in editor memory until scene_save or save_as is called. • save_as(path) Save the currently edited scene to a new file path. • get_roots() List scenes currently open in the editor; flag the edited one. • instantiate_batch(instances, parent_path="") Instantiate multiple PackedScenes into the active scene in a single UndoRedo action. instances: [{scene_path, name?, position?, rotation?, scale?, properties?}]. • diagnose(root_path="") Comprehensive health check / scene doctor for the open scene. Validates orphan collision shapes, unassigned shapes, non-uniform scaling, missing textures, camera configuration, and control hierarchy with actionable error/warning reports and fix suggestions.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Get properties of a node.

Resource form: godot://node/{path}/properties — prefer for active-session reads (returns the full property set).

The default returns every editor-visible property, which can be 50-150 entries. Pass fields to return only the properties you need — a large response-size cut on this hot read. The response always carries total_count (all editor-visible properties) alongside count (returned): an unfiltered call returns the full set, so count == total_count; only the fields filter can make count smaller. Requested names that match no editor-visible property are listed in unknown_fields, so a nonexistent name is distinguishable from a property that exists with a null value.

Null-valued properties are included: an unset object/resource slot (script on an unscripted node, an empty mesh or material, …) returns "value": null with its declared type. An attached script serializes to its res:// path; built-in scripts (no resource path) fall back to their string representation.

Create (spawn) a new node in the scene tree.

Creates a node of the given type and adds it to the parent, or instantiates a PackedScene from scene_path. type and scene_path are mutually exclusive — when scene_path is given, type is ignored.

Set a property on a node.

Verify the property name first — call node_get_properties (or read godot://node/{path}/properties) to confirm the exact name and type before writing. Guessing common Godot names often fails with PROPERTY_NOT_ON_CLASS because Godot's actual properties differ from intuition (e.g. Camera3D uses fov/current, not field_of_view; Sprite2D uses texture, not image; Node3D uses position/rotation/scale, not transform.origin).

Coerces value to the property's type:

• Vector2/Vector3: dict with x/y/z keys.

• Color: dict {r,g,b,a} or hex string ("#ff0000").

• NodePath: string ("../Other/Node").

• Resource: res:// path string (loads + assigns); null/"" clears. {"__class__": "BoxMesh", ...} creates a built-in resource owned by this property. After scene_save it is serialized in-place as a [sub_resource] inside the .tscn; it is not a reusable .tres. For sharing, first call resource_manage(op="create", params={"type": "BoxMesh", "properties": {...}, "resource_path": "res://meshes/box.tres"}), then pass that res:// path here (or use resource_manage(op="assign")).

• StringName: plain string. Array/Dictionary: JSON list/object.

Find nodes in the scene tree by name, type, or group.

At least one filter must be provided. Filters AND together. Paginated.

Node tree manipulation (delete, duplicate, rename, reorder, reparent, groups, hierarchy reads).

Resource forms (prefer for active-session reads): godot://node/{path}/properties, godot://node/{path}/children, godot://node/{path}/groups

Ops: • get_children(path) Direct children of a node (name, type, path each). • get_groups(path) Group names the node belongs to. • delete(path, scene_file="") Remove the node. Cannot delete scene root. Undoable. • duplicate(path, name="", scene_file="") Deep-copy a node + children as a sibling. Cannot duplicate scene root. • rename(path, new_name, scene_file="") Rename a node. Sibling-name collision and "/" / ":" / "@" rules apply. • move(path, index, scene_file="") Reorder among siblings. Index 0 = first. • reparent(path, new_parent, scene_file="") Move under a new parent. Children preserved. Cannot move into descendants. • add_to_group(path, group, scene_file="") Add the node to a group. • remove_from_group(path, group, scene_file="") Remove the node from a group. • rotate(path, degrees, axis="y", relative=false, scene_file="") Rotate a 2D or 3D node by degrees. Undoable. • scale(path, scale, relative=false, scene_file="") Scale a 2D or 3D node or Control. Undoable. • translate(path, offset, relative=true, scene_file="") Move / offset a node position. Undoable. • call_method(path, method, args=[], scene_file="") Call any method on a node with arguments.

All write ops accept the optional scene_file guard — if non-empty, the mutation fails with EDITED_SCENE_MISMATCH when the editor's current scene doesn't match.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Run (play) the Godot project from the editor.

Modes:

• "main": Run the project's main scene (default).

• "current": Run the currently open scene.

• "custom": Run a specific scene (requires scene).

Idempotent: if the project is already running, returns success with data.was_already_running=true (no scene switch). To switch scenes, call project_manage(op="stop") first, then project_run again.

After starting playback, waits briefly for the Godot AI game helper to check in. The response includes game_status, helper_live (status == "live"), session_active (status not in {"not_live", "stopped"}), and any recent_errors observed during the run window. The top-level booleans mirror the same fields inside game_status. game_status.status="not_live" means playback launched but the game did not become live before the helper-ready window elapsed; "no_helper" means the project has no _mcp_game_helper autoload, as with some headless/custom-main-loop setups (helper_live=false, session_active=true); "stopped" means playback stopped or never became active before liveness could be confirmed (helper_live=false, session_active=false); "break" means the game process is parked in a remote-debugger break — during boot this is a GDScript parse/load error that froze the game before the helper could register, and the response names the failing script when captured (game_status.break = {reason, can_debug, pre_live}). A game at a break cannot continue on its own: call project_manage(op="stop"), fix the error, and relaunch. Poll editor_state to see late transitions.

Project run/stop and project.godot settings.

Resource form: godot://project/info and godot://project/settings — prefer for active-session reads.

Ops: • stop() Stop the running project (game). Takes no params — call as project_manage(op="stop") or with params={}. Idempotent: succeeds with was_running=false if the project isn't running. Do NOT pass extra fields like force or reason inside params — only the registered keys are accepted (here, none). For multi-editor setups, pass session_id as a sibling of op/params, not inside params. • settings_get(key) Read a ProjectSettings key (e.g. "application/config/name"). • settings_set(key, value) Write a ProjectSettings key and persist to project.godot. Refuses the startup-execution keys (autoload/*, editor_plugins/*, application/run/main_scene, editor/run/main_run_args, editor/script/templates_search_path); use set_main_scene / autoload_manage(op="add") for the two that have a validated route. • set_main_scene(path) Set the project's main scene — the scene project_run(mode="main") boots and the engine loads at startup. Writes application/run/main_scene and persists to project.godot. path must be a res:// scene inside the project that already exists and loads as a PackedScene, so a scaffolded project can be made runnable without opening the generic startup-execution surface. • apply_preset(preset="pixel_art_2d", viewport_width=None, viewport_height=None) Configure project display resolution, stretch modes, and texture filtering in one atomic operation. Presets: 'pixel_art_2d' (320x180 viewport stretch, nearest filter), 'hd_2d' (1920x1080 canvas_items stretch, linear filter), 'low_poly_3d' (1280x720 canvas_items expand, FXAA), 'cinematic_3d' (1920x1080 canvas_items expand, 4x MSAA, FXAA, TAA).

• get_info() Retrieve comprehensive project metadata: Godot version, project name, project path, display settings, rendering settings, active scenes, and registered autoloads.

• get_map(max_files=180) Compact, read-only map of scenes, scripts, assets, resources, autoloads, input actions and open scenes. Results are capped and mark truncation.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Create a new GDScript source file (.gd) on disk.

Writes content to a .gd file in the project. Overwrites if it exists. Triggers a filesystem scan. New files include data.cleanup.rm listing the .gd + .gd.uid sidecar; overwrite omits it.

Anchor-based string-replace edit on a .gd file.

Finds an exact old_text and replaces with new_text. Fails on multiple matches unless replace_all=True; fails on zero matches. Exact byte match (whitespace significant). Triggers filesystem scan and refreshes an already-loaded GDScript in place so the next call runs the new code (response reloaded=true; otherwise reload_reason says why). Not undoable via Ctrl+Z.

Attach a script to a node in the scene tree.

Replaces any existing script on the node. Undoable.

Script (.gd) reading, detachment, and outline.

Resource form: godot://script/{path} — prefer for active-session reads.

Ops: • read(path) Read full source, line count, file size. • detach(path) Remove the currently attached script from a node. Undoable. • find_symbols(path) Outline a .gd — class_name, extends, functions, signals, @export vars. • validate(path="", content="") Validate a GDScript file or source string and return compiler diagnostics. • delete(path) Delete a script file and its .uid sidecar from the project.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Resource (asset) search, inspection, assignment, and creation. Covers generic Resource subclasses plus specialized authoring (Curve, Environment, physics shapes, gradient/noise textures).

Ops: • search(type="", path="", offset=0, limit=100) Search for resources by type or path. Type matching includes subclasses. At least one filter required. Paginated. • load(path) Inspect a .tres / .res — returns type and editor-visible properties. • assign(path, property, resource_path) Load and assign a resource to a node property. Undoable. • get_info(type) Introspect a Resource class — properties, parent, abstract flag, concrete_subclasses (for abstract bases). Read-only. • create(type, properties=None, path="", property="", resource_path="", overwrite=False) Instantiate a Resource subclass. Either path+property (assign to a node, undoable) or resource_path (save to .tres). For specific families (Curve, Environment, etc.) prefer the dedicated ops. • curve_set_points(points, path="", property="", resource_path="") Replace all points on a Curve / Curve2D / Curve3D. Auto-creates the curve resource if the slot is empty (curve_created flag). • environment_create(path="", preset="default", properties=None, sky=None, resource_path="", overwrite=False) Build Environment + Sky chain. Presets: default | clear | sunset | night | fog. sky may be bool or a procedural sky dict such as {"sky_material": "procedural", "sky_top_color": "#0f172a"}. Either assign to a WorldEnvironment node or save .tres. • environment_setup_3d(preset="daylight", parent_path="", create_sun=True, volumetric_fog=False, glow=False) Scaffold complete 3D environment and lighting. Presets: daylight | sunset | dark_dungeon | neon_night | clear. Auto-creates WorldEnvironment and DirectionalLight3D with matching sky, lighting, shadows, and tone mapping in a single undoable step. • environment_setup_2d(preset="dungeon", parent_path="", add_torch_to="", torch_energy=1.2, torch_radius=2.0, shadows=True) Scaffold complete 2D atmospheric lighting environment. Presets: dungeon | midnight | sunset | spooky | foggy. Creates CanvasModulate ambient tint, and optionally attaches a PointLight2D radial torch with falloff texture and shadows to the target character/object. • physics_shape_autofit(path, source_path="", shape_type="") Size a CollisionShape2D/3D to a nearby visual's bounds. Searches direct siblings then parent-siblings (handles nested Body→Collision layouts). Ambiguous matches return candidate paths in error.data.candidates. Auto-creates the concrete Shape subclass if needed. shape_type accepts either the short form ("box", "sphere", "capsule", "cylinder" for 3D; "rectangle", "circle", "capsule" for 2D) or the matching Godot class name ("BoxShape3D", "RectangleShape2D", etc.). • physics_shape_generate(paths, shape_type="box", body_type="static", scene_file="") Generate a StaticBody3D or Area3D sibling (named Collider) with a CollisionShape3D for every MeshInstance3D path. Shapes are fitted in body-local space; a mesh that already has a collider sibling, a duplicate path, or a scene-root mesh is refused before anything is written. shape_type: box | sphere | capsule | cylinder (or the class name); a sphere/capsule/cylinder under a non-uniformly scaled parent is refused. body_type: static | area. scene_file pins the request to that edited scene. Up to 1024 paths are processed in bounded work across editor frames; inside batch_execute at most 16. The bulk write is one undo action. Returns: {created: [{mesh_path, body_path, shape_path, shape_type, body_type}], undoable: true}. • gradient_texture_create(stops, width=256, height=1, fill="linear", path="", property="", resource_path="", overwrite=False) Build GradientTexture2D from color stops. fill: linear | radial | square. • noise_texture_create(noise_type="simplex_smooth", width=512, height=512, frequency=0.01, seed=0, fractal_octaves=0, path="", property="", resource_path="", overwrite=False) Build NoiseTexture2D wrapping FastNoiseLite. Noise types: simplex | simplex_smooth | perlin | cellular | value | value_cubic.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Inspect Godot API documentation-shaped metadata from the connected editor's ClassDB: "what properties does X have", method signatures, signals, enums, constants, defaults, and property hint strings.

Resource form (prefer for active-session reads): godot://class/{class_name}

Ops:

• get_class(class_name, sections=None, include_inherited=False, include_inheritors=False, offset=0, limit=100) Return selected class-reference sections without creating a scene instance. sections may be a comma-separated string or list containing properties, methods, signals, enums, constants, inheritors. Defaults to ["properties"] only — a bare get_class answers "what properties does X have" without the multi-thousand-token full dump. Pass the sections you want by name, or "all" for the full set (properties, methods, signals, enums, constants). "all" does NOT include the heavier "inheritors" section — request that by name. For pagination, request one section at a time so offset/limit apply only to the list you are paging.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Project filesystem access via the Godot editor's EditorFileSystem.

Ops: • read_text(path) Read a text file at a res:// path. Returns content, size, line_count. • write_text(path, content="") Create or overwrite a text file. Updates the editor filesystem entry for that one file (single-file update, not a full scan). Newly-created files include data.cleanup.rm for transient smoke tests; overwrite omits the field. • reimport(paths) Force-reimport the listed files via EditorFileSystem.update_file. paths is a list of res:// paths. Intended for imported assets such as textures, models, and audio. Paths that are not imported resources (.gd scripts, .tscn, hand-written .tres, or an asset the editor has not imported yet) report under skipped_non_imported rather than reimported: their filesystem entry is refreshed, but no import runs, so a success there is not evidence that a script parsed or that diagnostics were produced. Use script_patch/script_create to save a script and receive fresh diagnostics, or scan for an asset awaiting its first import. Returns reimported, skipped_non_imported, not_found and their counts. • list(path="res://", recursive=False, max_depth=1) Browse the project's res:// tree (files, sizes, UIDs, and directories). • delete(path) Delete a file or directory from the project along with its .uid and .import sidecars. • move(from_path, to_path) Move or rename a file in the project, keeping sidecars consistent. • scan() Force a full EditorFileSystem.scan() and wait for it to settle. This is the headless equivalent of the editor regaining window focus: write_text/script_create register single files but do NOT rebuild the global class_name table, so a freshly-created class_name MyThing extends Resource is invisible to resource_manage/type references until a scan runs. Call this once after adding class_name scripts when the editor isn't focused. Single-flight (awaits any in-progress scan rather than stacking another). Returns scan_completed and global_classes_registered_delta. • search(name="", type="", path="", offset=0, limit=100) Find files by name, resource type, or path substring. At least one filter must be set. Paginated. • download_and_import(url, dest="", path="", extract=False, filter="", reimport=True) Download an asset or archive, optionally unpack, configure filter ("nearest" for pixel art), and trigger Godot reimport and scan. • download_asset(url, path="", dest="", extract=False, filter="", reimport=True) Download an asset or zip archive from the internet directly into the Godot project (res:// path). If extract=True or archive is zip, extracts into target directory. Automatically triggers editor reimport and scan. Returns: {url, path, size_bytes, is_archive, extracted_files, filter_applied} • search_assets(query="", category="all", limit=20) Search curated free/CC0 game assets (tilesets, audio, textures, UI, 3D models). Categories: "all", "tileset", "audio", "texture", "ui". Returns matching assets with direct download URLs ready for download_asset.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Configure AI clients to use this Godot AI MCP server. Writes / removes client config files (Claude Code, Codex, Antigravity, Cursor, Devin Desktop (Windsurf), Zed, etc.).

Ops: • status() List every supported client with id, display_name, status (configured | not_configured | configured_mismatch | error), and installed flag. • configure(client) Write the MCP server entry into the named client's config file. client is one of the ids returned by status(). • remove(client) Remove this server's entry from the named client's config.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Signals (Godot's event/observer mechanism) — list, connect, disconnect.

Ops: • list(path, include_editor=False) List all signals on the node and their current connections (built-in and custom). By default editor-internal connections (the SceneTreeEditor dock and friends) are filtered out — pass include_editor=True to surface them. The response carries editor_connection_count so an agent can tell how many were hidden. • connect(path, signal, target, method) Connect a signal from path to a method on the target node. Undoable. • disconnect(path, signal, target, method) Remove an existing connection. Undoable.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Autoload (global singleton) management. Autoloads are scripts or scenes loaded automatically at project start, accessible globally by name when singleton=True. Persisted to project.godot.

Ops: • list() List autoloads with name, path, and singleton flag. • add(name, path, singleton=True) Register an autoload (script or PackedScene) by res:// path. • remove(name) Unregister an autoload by name. The underlying file is not deleted. • scaffold_game_manager(name="GameManager", script_path="res://scripts/game_manager.gd", max_lives=3) Scaffold and register a production-ready GameManager singleton with score, lives, level tracking, typed signals, and scene transition methods.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

InputMap actions and bindings (keyboard, mouse, gamepad). Persisted to project.godot.

Resource form: godot://input_map — prefer for active-session reads.

Ops: • list(include_builtin=False) List input actions and their bound events. By default only user-authored actions (those persisted in project.godot under input/<name>) are returned; pass include_builtin=True to also surface Godot's ui_* and editor-runtime actions (spatial_editor/*, etc.). The is_builtin field on each entry is true for any action not authored by the user. • add_action(action, deadzone=0.5) Create a new empty input action. deadzone must be in [0.0, 1.0] — Godot uses it as the analog-stick dead-zone threshold; values outside this range are rejected with VALUE_OUT_OF_RANGE. Typical values are 0.2-0.5; leave the default 0.5 unless you have a reason. Not a key-repeat delay. • ensure_action(action, deadzone=0.5) Idempotently create or persist an input action. If the action exists in live InputMap or in project.godot, the existing state is preserved. • remove_action(action) Remove an action and all its event bindings. Also removes actions persisted in project.godot but not loaded in the live InputMap (loaded_in_input_map: false in list), e.g. actions created by a previous editor session. • bind_event(action, event_type, keycode="", ctrl=False, alt=False, shift=False, meta=False, button=None, axis=None, axis_value=1.0) Bind a key/mouse/gamepad event to an action. The action must already exist (call add_action first). event_type is "key" | "mouse_button" | "joy_button" | "joy_axis". - key: keycode is a Godot keycode name string like "A", "Space", "Enter", "Escape", "F1", "Left" — not an integer and not KEY_*. Modifier booleans ctrl / alt / shift / meta optional. - mouse_button: button is an int — 1=left, 2=right, 3=middle, 4=wheel up, 5=wheel down. - joy_button: button is the JoyButton index (e.g. 0=A/Cross, 1=B/Circle). - joy_axis: axis is the JoyAxis index and axis_value is the direction/value, usually -1.0 or 1.0. • ensure_binding(action, event_type, ...) Idempotently ensure the action exists and has the requested binding. • scaffold_preset(preset="wasd_platformer") Scaffold a standard input mapping preset. Presets: 'wasd_platformer' (A/D/Space/W/Arrows), 'wasd_topdown' (WASD/Arrows/E/Space), 'first_person' (WASD/Space/Shift/E), 'driving' (W/S/A/D/Arrows/Space).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Runtime game inspection and input simulation.

These ops target the running game process through Godot's EngineDebugger bridge. Start the project first with project_run and poll editor_state until game_capture_ready=true.

Ops:

• get_scene_tree(depth=10, root_path="") Inspect the running scene tree. root_path accepts an absolute runtime path or a scene-relative path rooted at the current scene.

• get_node_info(path, include_properties=True) Inspect one running node's metadata and optional property snapshot.

• get_ui_elements(root_path="", include_hidden=False, include_disabled=True, max_depth=10) Inspect visible runtime Control nodes for UI testing. Includes path, type, text where present, disabled state, and rect metadata.

• suspend() Suspend the running game through Godot's native debugger path.

• resume() Resume a suspended game. Idempotent when it is already running.

• next_frame() Advance exactly one process tick while suspended. The response reports verification and any Embedded Game View focus handoff. Runtime-control mutations also report path="embed_signal" or "direct_session"; the direct fallback works without embedding but cannot synchronize the Game View suspend button's visual pressed state.

• debug_status() Probe suspend state and the game-helper process tick counter through the debugger capture, including while SceneTree processing is suspended.

• input_key(key, pressed=True, echo=False) Send a key press/release to the running game.

• input_mouse(event, position=None, button="left", pressed=True) Send a mouse motion or button event. event: "motion" | "button". position is a {x, y} object or [x, y] array; omit it to use the game's current cursor position. A present but malformed position is rejected rather than silently falling back to the cursor.

• input_gamepad(device=0, control="button", index=0, pressed=True, value=0.0) Send a joypad button or axis event. control: "button" | "axis".

• input_action(action, pressed=True, strength=1.0) Set a project action's pressed state directly in the running game.

• input_sequence(steps, settle_frames=0) Apply a frame-timed action timeline in one call — the frame-accurate, multi-step form of input_action. Each step is {at_frame, action, pressed=True, strength=1.0}; the game applies each step's action on its scheduled frame, awaits settle_frames more, then replies once. Use this instead of separate input_action calls whenever timing matters (jump arcs, combos, walk-into-trigger): per-call network latency makes hitting a target frame impossible otherwise. Steps must be ordered by non-decreasing at_frame; frames (not ms) are the timing basis. Action-based input is focus-independent, so it works on a backgrounded game window. Cannot run inside batch_execute.

• simulate_input(action="", key="", duration=0.5, press=True, strength=1.0) Simulate hardware or action input with duration and automatic clean release. For actions, executes a timed sequence and releases after duration seconds.

• input_state(actions=None) Read current action pressed states. Empty actions = all project actions.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Run GDScript test suites inside the connected Godot editor.

Discovers test_*.gd in res://tests/, instantiates them, and runs all test_* methods. Returns a compact summary by default (counts, suite names, duration) plus failures only. verbose=True includes every individual test result (each with per-test duration_ms).

Preloaded GDScript dependencies may remain stale after source edits; the response includes cache_warning. Restart the editor before using a rerun to validate dependency edits. ResourceLoader cache modes alone do not refresh the GDScript preload cache.

The whole run has a 300s budget; the plugin aborts between tests shortly before it expires and returns TEST_RUN_TIMEOUT with the partial summary (full partials via test_manage(op="results_get")). Long suites are safe — the editor services the MCP transport between tests — but one single test blocking the main thread for 20s+ can still drop the session. Not allowed inside batch_execute.

The response includes edited_scene (the scene currently open in the editor). Many suites assume the project's main scene is open; if it is not and there are failures, the response also carries a scene_warning — open the main scene (scene_open) and re-run before treating those failures as real.

Test result inspection (re-fetches the most recent test_run payload).

Resource form: godot://test/results — prefer for active-session reads.

Ops: • results_get(verbose=False) Same shape as test_run — full results from the last run, no re-execution. verbose=True includes every individual test result.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Execute a list of editor sub-commands in order, stopping on first error.

Each item must be {"command": "<plugin_command>", "params": {...}}. Use the underlying plugin command names (e.g. create_node, set_property, delete_node, attach_script), not the MCP tool names. Commands run sequentially; execution stops at the first error. When undo is True (default), any successful sub-commands are rolled back via the scene's undo history if a later sub-command fails, producing atomic-on-failure semantics.

With preview=True, only create_node/delete_node commands are accepted; returns the scene node list before and after, then undoes all changes. To keep the proposed change, call again with preview=False.

Use this to compose multi-step edits (create node + set property + attach script) into a single tool call. Rollback works for sub-commands that modify the currently edited scene. batch_execute itself is not allowed as a sub-command.

Scene paths are relative to the edited scene root (e.g. "/Main/Enemy"), NOT runtime "/root/..." paths. The example below assumes the scene root is named "Main" — substitute the actual root name.

UI / Control authoring (HUD, menus, layouts, vector decoration).

Ops: • set_anchor_preset(path, preset, resize_mode="minsize", margin=0) Apply a Control layout preset. preset: top_left | top_right | bottom_left | bottom_right | center_left | center_top | center_right | center_bottom | center | left_wide | top_wide | right_wide | bottom_wide | vcenter_wide | hcenter_wide | full_rect. resize_mode: minsize | keep_width | keep_height | keep_size. Target must be a Control. CanvasLayer is the canonical HUD parent but is not a Control — put a Control child under the CanvasLayer and apply the preset to that overlay. • set_text(path, text) Set text on a Label/Button/LineEdit/TextEdit/RichTextLabel. • build_layout(tree, parent_path="") Atomically build a UI subtree from a nested spec ({type, name?, properties?, anchor_preset?, anchor_margin?, theme?, children?}). Validates everything before mutating. properties is direct node properties only. Theme constants like container spacing live under theme_override_constants/<name> — e.g. {"theme_override_constants/separation": 8} on a VBoxContainer, not {"separation": 8} (which errors). theme and anchor_preset require a Control / Window — for a HUD, nest a Control under a CanvasLayer and apply them to the Control child, not the layer itself. • draw_recipe(path, ops, clear_existing=True) Attach a declarative list of vector _draw() ops to a Control — radar sweeps, gauges, corner brackets, crosshairs, waveforms. Op kinds: line | rect | arc | circle | polyline | polygon | string. • scaffold_screen(kind="main_menu", parent_path="", name="", title="", layer=10, buttons=None) Instantly scaffold a complete, production-ready UI screen hierarchy under a CanvasLayer with responsive anchors, panels, title headers, and buttons. Supported kinds: main_menu | pause_menu | hud | game_over | dialog_box.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Theme authoring (Godot's stylesheet-like resource for Controls). Cascades down a Control subtree when assigned via theme_apply.

Ops (pass via op="..." plus a params dict): • create(path, overwrite=False) Create a new empty Theme .tres at a res:// path. • set_color(theme_path, class_name, name, value) Set a color slot. value: "#rrggbb"/"#rrggbbaa", named, or {"r","g","b","a"}. • set_constant(theme_path, class_name, name, value) Set an integer constant (separation, margin, padding). • set_font_size(theme_path, class_name, name, value) Set a font_size slot in pixels. • set_stylebox_flat(theme_path, class_name, name, bg_color?, border_color?, border?, corners?, margins?, shadow?, anti_aliasing?) Compose a StyleBoxFlat (panels, button states, line edits). border/corners/margins/shadow each accept "all" + per-side keys. • apply(node_path, theme_path="") Assign the theme to a Control (cascades to descendants). Empty theme_path clears. • apply_preset(preset="dark_modern", theme_path="", node_path="", set_as_default=False, overwrite=True) Apply a full cohesive Theme preset (Button states, Panels, LineEdits, Sliders, ProgressBars, Labels) in one call. Presets: 'cyberpunk_neon', 'dark_modern', 'retro_pixel', 'fantasy_parchment', 'clean_light'.

All ops accept session_id on the wrapper to target a specific editor.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Create a new Animation clip inside an AnimationPlayer's default library.

After creating the clip, add tracks via animation_manage ops add_property_track / add_method_track / create_simple. Track node paths are stored relative to the AnimationPlayer's root_node (default: its parent), not to the scene root — see animation_manage preset ops for a forgiving target_path that accepts either form. If player_path doesn't resolve, an AnimationPlayer is auto-created at that path (parent must exist).

AnimationPlayer authoring (player, tracks, autoplay, presets, playback).

Ops: • player_create(parent_path, name="AnimationPlayer") Create an AnimationPlayer with empty default library. • delete(player_path, animation_name) Delete an animation clip from the default library. Undoable. • validate(player_path, animation_name) Check all track paths resolve. Returns broken_count + per-track issues. • add_property_track(player_path, animation_name, track_path, keyframes, interpolation="linear") Add a property track. track_path: "NodeName:property". keyframes: [{time, value, transition?}, ...]. interpolation: linear|nearest|cubic. • add_method_track(player_path, animation_name, target_node_path, keyframes) Add a method track. keyframes: [{time, method, args?}, ...]. • set_autoplay(player_path, animation_name="") Set autoplay. Empty animation_name clears. • play(player_path, animation_name="") Editor preview. Not saved with scene. • stop(player_path) Stop editor preview. Not saved with scene. • list(player_path) List animations with length, loop_mode, track_count. • get(player_path, animation_name) Inspect a clip's tracks and keyframes in detail. • create_simple(player_path, name, tweens, length=None, loop_mode="none", overwrite=False) High-level: build a multi-track clip from tween specs in one call. tweens: [{target, property, from, to, duration, delay?, transition?}]. • preset_fade(player_path, target_path, mode="in", duration=0.5, animation_name="", overwrite=False) One-call fade-in/out (modulate.a). • preset_slide(player_path, target_path, direction="left", mode="in", distance=None, duration=0.4, animation_name="", overwrite=False) One-call slide-in/out (position). • preset_shake(player_path, target_path, intensity=None, duration=0.3, frequency=30.0, seed=0, animation_name="", overwrite=False) One-call shake (jittered position). • preset_pulse(player_path, target_path, from_scale=1.0, to_scale=1.1, duration=0.4, animation_name="", overwrite=False) One-call pulse / hover-bounce (3-keyframe scale ping-pong).

Preset target_path: accepts either a scene-absolute path (e.g. "/Main/World/Cube", matching every other scene tool) or a path relative to the AnimationPlayer's root_node (e.g. "World/Cube", matching how Animation tracks store node paths). Scene-absolute targets outside the player's root_node subtree are converted to a ..-prefixed track path via root_node.get_path_to(target), the same shape the relative form already accepts.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Material authoring (StandardMaterial3D, ORMMaterial3D, ShaderMaterial, CanvasItemMaterial). Albedo, metallic/roughness, emission, transparency, shader uniforms.

Resource form: godot://materials — prefer for active-session reads.

Ops: • create(path, type="standard", shader_path="", overwrite=False) Create + save a material .tres at a res:// path. type: "standard" | "orm" | "canvas_item" | "shader". For "shader", shader_path points to the .gdshader. • set_param(path, param, value) Set a built-in property on a .tres material. Enum-valued params accept names ("alpha" -> TRANSPARENCY_ALPHA). Color/Vector dicts. Texture properties accept res:// paths. • set_shader_param(path, param, value) Set a shader uniform on a ShaderMaterial. • get(path) Inspect a material (type, params, uniforms, current values). • list(root="res://", type="") List materials under root, optional type filter. • assign(node_path, resource_path="", slot="override", create_if_missing=False, type="standard") Assign a material to a node slot. Slots: "override" | "surface_" | "canvas" | "process". When create_if_missing=True and no resource_path, makes an inline material of type. • apply_to_node(node_path, type="standard", params=None, slot="override", save_to="", overwrite=False) High-level: build + set params + assign in one undo. save_to optionally persists to disk; errors if the file already exists unless overwrite=True. • apply_preset(preset, path="", node_path="", overrides=None) Curated looks: metal, glass, emissive, unlit, matte, ceramic. path saves to disk; node_path assigns to a node; overrides merge.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Particle systems (GPUParticles2D/3D, CPUParticles2D/3D). All write ops create the node + sub-resources (ProcessMaterial, default QuadMesh draw pass) in a single undo action.

Ops: • create(parent_path, name="Particles", type="gpu_3d") Create an emitter. type: "gpu_3d" | "gpu_2d" | "cpu_3d" | "cpu_2d". For GPU emitters, auto-creates ProcessMaterial; for gpu_3d, also a default QuadMesh draw pass. • set_main(node_path, properties) Node-level props: amount, lifetime, one_shot, explosiveness, preprocess, speed_scale, randomness, fixed_fps, emitting, local_coords, interp_to_end. • set_process(node_path, properties) Behavior props (auto-creates ProcessMaterial for GPU). Emission shape, velocity, gravity, color_ramp, scale_curve, turbulence. See full property list in the Godot reference. GPU gravity is a Vector3 — pass {x, y, z} or [x, y, z], including for gpu_2d (the shared ProcessMaterial is 3D; z is ignored in 2D). • set_draw_pass(node_path, pass_=1, mesh="", texture="", material="") What gets drawn per particle. GPU 3D: mesh in draw_pass_N + optional material override. GPU 2D / CPU 2D: texture. CPU 3D: mesh. • restart(node_path) Restart emission. Runtime-only, not undoable. • get(node_path) Inspect main props, process material, draw passes. • apply_preset(parent_path, name, preset, type="gpu_3d", overrides=None) Curated effects: fire, smoke, spark_burst, magic_swirl, rain, explosion, lightning. One-shot presets re-trigger via restart. overrides = {"main": {...}, "process": {...}, "draw": {...}}; bare keys are auto-routed to main (amount, lifetime, one_shot, ...) or process — draw keys must be nested under "draw". draw configures the gpu_3d draw-pass StandardMaterial3D (blend_mode, albedo_color, emission, ...); on gpu_2d only draw.texture (res:// path) applies; cpu_* types reject draw overrides. Unknown or malformed override keys return INVALID_PARAMS (never silently dropped); response reports applied_main / applied_process / applied_draw. GPU gravity requires {x, y, z} (or [x, y, z]) even for gpu_2d.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Camera2D / Camera3D authoring (zoom, FOV, projection, smoothing, follow).

Ops: • create(parent_path, name="Camera", type="2d", make_current=False) Create a Camera2D ("2d") or Camera3D ("3d"). When make_current=True, unmarks previously current cameras of the same class in one undo. • configure(camera_path, properties) Batch-set camera-specific properties (zoom, fov, projection, smoothing, drag, limits …). Class-aware. Enum-by-name (projection, keep_aspect, anchor_mode, doppler_tracking, process_callback). Vector2 dict coercion for zoom/offset. Transforms (position, rotation, scale, transform, global_*) live on the Node — set those via node_set_property, not here. • set_limits_2d(camera_path, left?, right?, top?, bottom?, smoothed?) Set Camera2D bounds. Pass only the edges to change. • set_damping_2d(camera_path, position_speed?, rotation_speed?, drag_margins?, drag_horizontal_enabled?, drag_vertical_enabled?) Smooth Camera2D motion (position/rotation smoothing speeds + drag deadzone). drag_margins: {left,top,right,bottom} fractions [0,1]. • follow_2d(camera_path, target_path, smoothing_speed=5.0, zero_transform=True) Reparent camera under target with smoothing — Godot-native follow. • scaffold_follow_2d(target_path="", parent_path="", name="FollowCamera2D", smoothing_speed=5.0, zoom=None, enable_shake=True, make_current=True, limits=None) Scaffold complete follow Camera2D with position smoothing and trauma-based screen shake (adds add_trauma() method to camera). • get(camera_path="") Inspect a camera (class, current flag, all properties). Empty path resolves to the currently-active camera, falling back to the first. • list() List every Camera2D/Camera3D in the scene. • apply_preset(parent_path, name, preset, type=None, make_current=True, overrides=None) Spawn with opinionated defaults. Presets: topdown_2d, platformer_2d, cinematic_3d, action_3d. overrides merge over preset values.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Sound effects, music, ambience (AudioStreamPlayer / 2D / 3D).

Ops: • player_create(parent_path, name="AudioStreamPlayer", type="1d") Create an AudioStreamPlayer / 2D / 3D node. type: "1d" | "2d" | "3d". • player_set_stream(player_path, stream_path) Assign an AudioStream resource (.ogg/.wav/.mp3 or .tres). Returns duration_seconds. • player_set_playback(player_path, volume_db?, pitch_scale?, autoplay?, bus?) Update common playback properties atomically. Pass only fields to change; at least one of volume_db/pitch_scale/autoplay/bus required. • play(player_path, from_position=0.0) Start real editor preview playback. Not undoable. • stop(player_path) Stop editor preview playback. Not undoable. • list(root="res://", include_duration=True) Scan project for AudioStream resources (every subclass + .tres/.res). • generate_procedural_sfx(preset="jump", dest_path="", duration=0.0, sample_rate=22050) Synthesize a chiptune PCM .wav sound effect directly into res://. Presets: jump | coin | laser | hit | explosion | powerup | step | click. • scaffold_buses(volumes=None) Configure standard Master, Music, SFX, and UI audio buses in AudioServer. • scaffold_music_player(parent_path="", name="MusicPlayer", stream_path="", autoplay=True, volume_db=0.0, bus="Music", loop=True) Scaffold a dedicated background music player (AudioStreamPlayer) routed to the Music bus with autoplay and loop configuration. • scaffold_sound_manager(name="SoundManager", script_path="res://scripts/sound_manager.gd", pool_size=16, bus="SFX", register_autoload=True) Scaffold a multi-channel sound effect manager singleton with AudioStreamPlayer pooling, pitch variation, and 2D spatial audio helper. • bus_list() List all AudioServer buses with their properties and effects. • bus_add(name, send="Master", volume_db=0.0, at_pos=-1) Add a new audio bus and route it to a parent bus. • bus_remove(bus) Remove an audio bus by name or index. • bus_set_properties(bus, volume_db?, send?, solo?, mute?, bypass_effects?) Update properties on an existing bus. • bus_add_effect(bus, effect_type, at_position=-1, enabled=True, params={}) Add an audio effect to a bus. Types: Reverb, Delay, Chorus, Phaser, Distortion, EQ, Compressor, Limiter, LowPassFilter, HighPassFilter, BandPassFilter, NotchFilter, Amplify. • bus_save_layout(path="res://default_bus_layout.tres") Save the current AudioServer bus layout to a resource file.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

2D and 3D Character Controller Scaffolding.

Ops: • scaffold_2d(parent_path="", name="Player", genre="platformer", speed=200.0, jump_velocity=-350.0, acceleration=1200.0, friction=1000.0, coyote_time=0.12, jump_buffering=0.1, attach_camera=True, script_path="") Instantly scaffold a complete 2D player character (CharacterBody2D) with CollisionShape2D, placeholder graphics, optional follow camera with screen shake, and production-ready controller script with coyote time, jump buffering, floor snapping, and move_and_slide(). Genres: 'platformer' (gravity, jump) | 'topdown' (4/8-way movement).

• scaffold_3d(parent_path="", name="Player3D", genre="first_person", speed=5.0, sprint_speed=8.0, jump_velocity=4.5, mouse_sensitivity=0.002, script_path="") Instantly scaffold a complete 3D player character (CharacterBody3D) with CapsuleShape3D, CapsuleMesh, and Camera3D with mouse-look capture, sprinting, jumping, gravity, and move_and_slide(). Genres: 'first_person' (head-mounted camera) | 'third_person' (SpringArm3D).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Dialogue and Narrative System Management.

Ops: • scaffold_system(name="DialogueManager", script_path="res://scripts/dialogue_manager.gd", scene_path="res://scenes/dialogue_box.tscn", register_autoload=True, typewriter_speed=0.03) Scaffold a complete dialogue manager singleton and UI box with typewriter animation, BBCode rich text, continue indicator, branching choice buttons, and event signals (dialogue_started, line_displayed, choice_selected, dialogue_ended).

• create_dialogue(path="res://dialogues/dialogue.json", dialogue_id="intro_conversation", nodes={}, overwrite=False) Create a structured branching dialogue graph with speakers, text lines, choice options, and next-node pointers.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Save Game and Persistence Management.

Ops: • scaffold_save_system(name="SaveManager", script_path="res://scripts/save_manager.gd", save_directory="user://saves/", register_autoload=True, enable_encryption=False, encryption_password="") Scaffold an atomic, corruption-resistant SaveManager singleton that automatically orchestrates saving and loading across all nodes in the 'saveable' group, with optional password encryption and slot management.

• save_slot(slot_name="slot_1", data={}, directory="user://saves/") Save arbitrary game state data into a designated slot atomically.

• load_slot(slot_name="slot_1", directory="user://saves/") Load state data from a designated slot.

• list_slots(directory="user://saves/") List all saved game slots, timestamps, and metadata.

• delete_slot(slot_name="slot_1", directory="user://saves/") Delete a save game slot.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Finite State Machine (FSM) Management.

Ops: • scaffold_fsm(target_node_path="", name="StateMachine", script_dir="res://scripts/fsm/", preset="enemy_ai", custom_states=[], initial_state="") Scaffold a modular node-based finite state machine architecture with base State class and StateMachine controller. Presets: - 'enemy_ai': Idle, Patrol, Chase, Attack, Hurt, Dead states. - 'character': Idle, Move, Jump, Fall states. - 'custom': Generates scripts for names listed in custom_states. If target_node_path is specified, attaches the StateMachine and child State nodes directly to the target node in the active scene.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

TileMap / TileMapLayer authoring (set tiles, fill rects, clear, read cells, generate layouts).

CRITICAL DIRECTIVE: ALWAYS place tiles directly down into the TileMap or TileMapLayer node in the active editor scene using this tool. NEVER generate maps by writing procedural GDScript code in _ready() unless the user explicitly requested runtime procedural generation. Direct tile placement enables visual editing, native Godot physics, and instant editor inspection.

All operations target TileMapLayer or TileMap nodes in the currently edited scene by scene-relative path (e.g. "/LavaLake20x20/Ground"). All write ops are undoable via EditorUndoRedoManager.

source_id is the TileSet source index. atlas_col/atlas_row are the atlas coordinates of the tile within that source. For full-tile animated sources (lava, water, sewage) use atlas_col=0, atlas_row=0.

IMPORTANT — Source-ID remapping in specialized .tres files: When a layer uses a specialized .tres (e.g. volcano_animated.tres), Source-IDs are re-numbered from 0. Example: volcano lava is Source 8 in the main volcano.tres but Source 0 in volcano_animated.tres. Always use the remapped ID when the TileMapLayer references a specialized .tres, not the original ID from the main .tres.

Ops: • tilemap_set_cell(path, source_id, atlas_col, atlas_row, map_x, map_y) Set a single tile at (map_x, map_y). Returns: {map_x, map_y, source_id, atlas_col, atlas_row}

• tilemap_set_cells_rect(path, source_id, atlas_col, atlas_row, rect_x, rect_y, rect_w, rect_h) Fill a rect_w × rect_h region starting at (rect_x, rect_y) with one tile type in a single undo action. Returns: {cells_filled, rect: {x, y, w, h}}

• tilemap_clear(path) Remove all tiles from the layer. Returns: {cleared: true}

• tilemap_get_cells(path) Return all used cell coordinates. Returns: {cells: [{x, y}, ...], count: int}

• tilemap_place_tile(path, source_id, atlas_col, atlas_row, map_x, map_y, rotation_degrees=0, flip_h=false, flip_v=false, alternative_tile=-1) Place a tile with exact rotation (0, 90, 180, 270) and flip flags. Returns: {map_x, map_y, source_id, atlas_col, atlas_row, alternative_tile, rotation_degrees, flip_h, flip_v}

• tilemap_rotate_cell(path, map_x, map_y, degrees=90) Rotate tile cell at (map_x, map_y) clockwise by degrees (90, 180, 270). Returns: {map_x, map_y, degrees, old_alternative, new_alternative}

• tilemap_flip_cell(path, map_x, map_y, flip_h=false, flip_v=false) Flip an existing tile cell at (map_x, map_y) horizontally and/or vertically. Returns: {map_x, map_y, flip_h_applied, flip_v_applied, new_alternative}

• tilemap_erase_cell(path, map_x, map_y) Erase a single tile cell at (map_x, map_y). Returns: {map_x, map_y, erased}

• tilemap_get_cell(path, map_x, map_y) Get detailed information of a tile cell. Returns: {has_tile, map_x, map_y, source_id, atlas_col, atlas_row, alternative_tile, flip_h, flip_v, transpose}

• tilemap_generate_layout(path, genre="platformer", rect_w=32, rect_h=18, rect_x=0, rect_y=0, source_id=0, floor_col=0, floor_row=0, wall_col=1, wall_row=0, accent_col=2, accent_row=0, layer=0) Generate a complete layout placed directly into the editor. Supported genres: 'platformer', 'topdown', 'rpg', 'dungeon', 'arena'. Returns: {genre, cells_placed, rect, source_id, layer, undoable}

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

TileSet management — atlas inspection tools.

Ops: • tileset_diagnose(tileset_path, check_collision=False, physics_layer=0, max_findings=80) Read-only TileSet doctor: missing textures, atlas sizing, tiles outside textures, tile pixel-size inconsistencies, and optional missing collision. Collision checks are opt-in because decorative tiles need no shapes. Rotated tile variants are not errors by themselves.

• tileset_get_atlas_tiles(tileset_path, source_id) Return all occupied atlas tile positions for one source in a TileSet. Read-only — does not modify any resource or project file.

    tileset_path: res:// path to the .tres TileSet resource (required)
    source_id:    raw TileSet source id of the TileSetAtlasSource to query (required, ≥ 0)

    Returns:
      {"tiles": [{"col": int, "row": int}, ...], "count": int}

    Error codes (passed through from GDScript handler):
      MISSING_REQUIRED_PARAM  — tileset_path empty or source_id absent
      RESOURCE_NOT_FOUND      — tileset_path does not exist on disk
      WRONG_TYPE              — not a TileSet, or source is not a TileSetAtlasSource
      VALUE_OUT_OF_RANGE      — source_id does not exist in this TileSet

• tileset_get_atlas_image(tileset_path, source_id, max_size=0) Return the atlas sprite-sheet texture of a TileSetAtlasSource as a Base64-encoded PNG image. Read-only — reads the texture directly from the resource without any UI interaction.

    tileset_path: res:// path to the .tres TileSet resource (required)
    source_id:    raw TileSet source id of the TileSetAtlasSource to query (required, ≥ 0)
    max_size:     optional int; if > 0, scale the image so its longest
                  edge is at most max_size pixels (default 0 = full res)

    Returns:
      {"image_base64": str, "width": int, "height": int,
       "original_width": int, "original_height": int, "format": "png"}

    Error codes (passed through from GDScript handler):
      MISSING_REQUIRED_PARAM  — tileset_path empty or source_id absent
      RESOURCE_NOT_FOUND      — tileset_path does not exist on disk
      WRONG_TYPE              — not a TileSet, source not a TileSetAtlasSource,
                                or source has no texture assigned
      VALUE_OUT_OF_RANGE      — source_id does not exist in this TileSet

• Atlas image workflow: To visually inspect what tiles look like, use tileset_get_atlas_image instead of editor screenshots. It reads the texture directly from the resource — no UI interaction or editor state required.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

GridMap authoring (set items, fill 3D regions, clear, read cells + library items).

All operations target GridMap nodes in the currently edited scene by scene-relative path (e.g. "/Main/Terrain"). All write ops are undoable via EditorUndoRedoManager.

item is the item id from the GridMap's MeshLibrary. Use gridmap_list_library_items to discover valid ids and names before placing cells (the 3D analogue of tileset atlas inspection). orientation is the GridMap baked rotation index (0..24).

Ops: • gridmap_set_item(path, item, map_x, map_y, map_z, orientation=0) Set a single cell item at (map_x, map_y, map_z). item=-1 erases. Returns: {map_x, map_y, map_z, item, orientation}

• gridmap_fill(path, item, rect_x, rect_y, rect_z, rect_w, rect_h, rect_d, orientation=0) Fill a rect_w × rect_h × rect_d region starting at (rect_x, rect_y, rect_z) with one item in a single undo action. Returns: {cells_filled, rect: {x, y, z, w, h, d}}

• gridmap_clear(path) Remove all cells from the GridMap. Returns: {cleared: true}

• gridmap_get_used_cells(path) Return all used cell coordinates. Returns: {cells: [{x, y, z}, ...], count: int}

• gridmap_list_library_items(path) List the MeshLibrary items available to the GridMap. Returns: {library, items: [{item, name, mesh}...], count: int}

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

CSG authoring (create boolean shapes, set their operation).

Create CSG shapes (box, sphere, cylinder, torus, polygon) under a Node3D parent in the currently edited scene and set their boolean operation (union / intersection / subtraction) so geometry like holes, caves and tunnels can be carved directly in the editor. All write ops are undoable via EditorUndoRedoManager. Sibling CSG shapes under the same parent combine automatically; use a CSGCombiner3D parent for explicit grouping. Size, position and material live on the created node — set them with node_set_property / material_manage after creation.

Ops: • csg_create(parent_path, name="", shape="box", operation="union") Create a CSG shape under a Node3D parent (empty parent_path = scene root). shape: box | sphere | cylinder | torus | polygon. operation: union | intersection | subtraction. Returns: {path, name, shape, operation}

• csg_set_operation(path, operation) Set the boolean operation of a CSG shape. operation: union | intersection | subtraction. Returns: {operation}

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

2D and 3D Navigation and Pathfinding.

Ops: • setup_region_2d(parent_path="", name="NavigationRegion2D", polygon=None, cell_size=1.0, agent_radius=10.0, parsed_geometry_type="mesh_instances_and_colliders") Setup NavigationRegion2D with NavigationPolygon, boundary vertices, and geometry parsing configuration in one undo action. • attach_agent_2d(node_path, agent_name="NavigationAgent2D", radius=16.0, max_speed=150.0, path_desired_distance=20.0, target_desired_distance=20.0, avoidance_enabled=True) Attach and configure NavigationAgent2D under character/enemy node. • bake_2d(region_path, on_thread=False) Trigger in-editor baking of 2D navigation polygon. • setup_region_3d(parent_path="", name="NavigationRegion3D", cell_size=0.25, cell_height=0.25, agent_radius=0.5, agent_height=1.8) Setup NavigationRegion3D with NavigationMesh in one undo action. • attach_agent_3d(node_path, agent_name="NavigationAgent3D", radius=0.5, height=1.8, max_speed=5.0, path_desired_distance=1.0, target_desired_distance=1.0, avoidance_enabled=True) Attach and configure NavigationAgent3D under character/enemy node. • bake_3d(region_path, on_thread=False) Trigger in-editor baking of 3D navigation mesh.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

List or invoke custom tools registered by third-party addons.

Active session only. Use op="list" to discover registered tools. op="invoke" requires params: tool_name (string); optional: params (dict, forwarded to the addon handler unvalidated — shape per the tool's params_schema from op="list"). Inside batch_execute, address a custom tool as "custom_tool:" (deferred tools cannot run in batches). Some custom tools are also registered first-class as "custom_" with their own schema — prefer those when present.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Universal Godot engine control, reflection, script evaluation, and editor UI automation.

Ops:

• eval(code, mode="auto", inputs={}) Execute arbitrary GDScript in the Editor process with full permissions.

• call(target, method, args=[]) Call ANY method on ANY Godot Object (Node, Resource, Singleton, RefCounted).

• get(target, property) Read any property on any Godot Object.

• set(target, property, value) Write any property on any Godot Object.

• inspect(target) Inspect complete methods, properties, and signals of any Object.

• instantiate(class_name="", script_path="") Instantiate any ClassDB class or GDScript.

• ui_tree(max_depth=8) Extract the full hierarchical semantic UI Control tree of the Editor.

• ui_click(text="", path="") Click any button, tab, checkbox, or control in the Editor.

• ui_type(text, target="") Type text into any LineEdit or TextEdit in the Editor.

• instantiate_prefab(scene_path, parent_path="", node_name="", position=None) Instantiate any .tscn prefab directly into the edited scene.

• shader_create(shader_path, shader_type="canvas_item", code="", target_node_path="") Create a new GDShader and optionally assign it as a ShaderMaterial to a node.

• mesh_primitive(primitive_type="box", node_name="", parent_path="", size=None, albedo_color=None, position=None) Create a 3D primitive mesh (box, sphere, cylinder, plane, capsule, prism).

• collision_shape(parent_path, shape_type="box", is_2d=True, size=None, radius=16.0, height=32.0, node_name="CollisionShape") Create a 2D or 3D CollisionShape and attach it to a physics body.

• preset_motion(preset="pulse", target_node_path="", animation_player_path="", anim_name="", duration=1.0, loop=True) Inject procedural motion presets (pulse, fade_in, fade_out, slide_in).

• ping() Quick diagnostic ping returning engine version, process frames, and memory metrics.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Shader System and Visual Effect Management.

Ops:

• create(path="res://shaders/custom.gdshader", shader_type="canvas_item", code="", overwrite=False) Create a new .gdshader resource with boilerplate for canvas_item, spatial, particles, sky, or fog.

• apply_preset(preset="outline_2d", target_node_path="", shader_path="", params={}) Compile and apply production shader presets: - outline_2d: Dynamic sprite border outline (outline_color, outline_width). - hit_flash: Combat damage flash effect (flash_color, flash_modifier). - dissolve_2d: Burning noise dissolve effect (dissolve_amount, burn_color, burn_size). - water_2d: Wave distortion and reflection (water_tint, wave_speed, wave_freq, wave_amp). - foliage_wind: Vertex displacement wind sway (wind_speed, wind_strength). - crt_scanline: Retro CRT monitor scanlines, curvature, and vignette. - hologram_glitch: Sci-fi holographic glitch and scanlines (holo_color, scanline_density). Optionally assign directly to target node's material.

• set_param(param="outline_width", value=2.0, target_node_path="", material_path="") Set a uniform parameter on a ShaderMaterial by target node or material path.

• get_params(target_node_path="", material_path="") Inspect shader code and parameters from a target node or material path.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Physics Queries, Raycasting, and Sensor Scaffolding.

Ops:

• raycast_2d(from_pos=[0, 0], to_pos=[0, 100], collision_mask=4294967295, collide_with_bodies=True, collide_with_areas=False, hit_from_inside=False) Perform a 2D raycast query directly through the active World2D physics space, returning collision point, normal, collider path, and shape.

• raycast_3d(from_pos=[0, 10, 0], to_pos=[0, -10, 0], collision_mask=4294967295, collide_with_bodies=True, collide_with_areas=False, hit_from_inside=False) Perform a 3D raycast query directly through the active World3D physics space, returning collision point, normal, collider path, and shape.

• query_point_2d(point=[0, 0], collision_mask=4294967295, max_results=32, collide_with_bodies=True, collide_with_areas=False) Query intersecting physics bodies and areas overlapping a 2D world coordinate.

• scaffold_sensor(parent_path="", target_position=[0, 50], is_2d=True, sensor_name="GroundSensor", collision_mask=1, enabled=True) Instantiate and attach a RayCast2D or RayCast3D sensor to a character or node.

• query_point_3d(point=[0, 0, 0], collision_mask=4294967295, max_results=32, collide_with_bodies=True, collide_with_areas=False) Query intersecting physics bodies and areas overlapping a 3D world coordinate.

• shapecast_scaffold(parent_path="", shape_type="sphere", radius=1.0, is_2d=False, sensor_name="ShapeCast", collision_mask=1) Create a ShapeCast2D or ShapeCast3D node with the specified collision shape.

• set_layer_names(layer_type="2d_physics", layers={"1": "Environment", "2": "Player"}) Set project-wide layer names (layer_type: 2d_physics | 3d_physics | 2d_render | 3d_render).

• get_layer_names(layer_type="all") Get configured layer names (layer_type: 2d_physics | 3d_physics | 2d_render | 3d_render | all).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Godot TranslationServer Localization and CSV Translation Workflows.

Ops:

• scaffold_csv(path="res://localization.csv", languages=["en", "es", "fr", "de", "ja", "zh"]) Generate a starter localization CSV file and register it in ProjectSettings.

• add_entry(path="res://localization.csv", key="ui_start", translations={"en": "Start", "es": "Iniciar"}) Add or update a translation string row in the project's localization CSV.

• get_locales() Query loaded locales, active locale, and translation settings from TranslationServer.

• set_locale(locale="es") Switch the active test locale in TranslationServer.

• translate(message="ui_start", context="") Test and evaluate translation string resolution via TranslationServer.

• extract_strings(root_dir="res://") Scan project GDScript and scene files for tr() message lookup occurrences.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Constructive 2D Solid Geometry and Procedural 3D Mesh Generation.

Ops:

• polygon_boolean(operation="merge", poly_a=[...], poly_b=[...]) Perform 2D constructive solid polygon operations (merge, clip, intersect, exclude).

• polygon_offset(polygon=[...], delta=5.0, join_type="square") Deflate or inflate a 2D polygon via Geometry2D.offset_polygon.

• triangulate(polygon=[...]) Triangulate a 2D polygon into index arrays via Geometry2D.triangulate_polygon.

• convex_hull(points=[...]) Compute the 2D convex hull wrapping an arbitrary point set.

• scaffold_polygon_2d(parent_path="", points=[...], polygon_name="CustomPolygon", is_collision=False, color=[1.0, 1.0, 1.0, 1.0]) Instantiate and attach a Polygon2D or CollisionPolygon2D to the active scene.

• generate_mesh(mesh_type="cube", size=[2.0, 2.0, 2.0], dest_path="", parent_path="") Generate a procedural 3D mesh via SurfaceTool (cube, plane, pyramid) and attach to scene or save.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Godot Viewport and SubViewport Lifecycle, Splitscreen, and Render Texture Routing.

Ops:

• create_subviewport(parent_path="", name="SubViewport", size=[512, 512], render_target_update_mode=3, transparent_bg=false, own_world_3d=false, as_container=false) Create a SubViewport or SubViewportContainer in the active scene.

• scaffold_splitscreen(layout="2p_horizontal", is_3d=false, parent_path="") Scaffold a multi-player splitscreen layout (2p_horizontal, 2p_vertical, 4p_quad) with SubViewports, SubViewportContainers, and independent cameras.

• wire_render_texture(viewport_path, target_node_path, target_property="") Route a SubViewport's ViewportTexture into a Sprite2D, TextureRect, or MeshInstance3D material albedo.

• get_viewport_tree() Inspect all Viewports in the active scene, their sizes, update modes, and active cameras.

• set_properties(viewport_path, size=..., transparent_bg=..., render_target_update_mode=..., own_world_3d=..., msaa_2d=..., msaa_3d=..., screen_space_aa=..., use_hdr_2d=...) Configure rendering fidelity and options for an existing Viewport.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

High-Level Godot Multiplayer Networking Scaffolding and Topology Inspection.

Ops:

• scaffold_network_manager(save_path="res://scripts/network_manager.gd", default_port=8910, max_clients=32, as_autoload=false, autoload_name="NetworkManager") Generate an ENetMultiplayerPeer network manager script with host/join/disconnect methods and peer signal handling.

• scaffold_spawner(parent_path="", spawner_name="MultiplayerSpawner", spawn_path="..", spawnable_scenes=[...], auto_spawn=true) Attach and configure a MultiplayerSpawner node with spawnable scene paths.

• scaffold_synchronizer(parent_path="", synchronizer_name="MultiplayerSynchronizer", root_path="..", properties=[":position", ":rotation"]) Attach and configure a MultiplayerSynchronizer node with SceneReplicationConfig.

• get_network_status() Query active multiplayer peer state, server role, unique ID, and connected peers.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Procedural Motion, Game-Feel Tween Recipes, and Tween Code Generation.

Ops:

• create(node_path, property, target_value, duration=0.5, trans_type="linear", ease_type="in_out", delay=0.0, relative=false) Create and run a Tween interpolating a property on a node.

• preset_animation(node_path, preset="punch_scale", duration=0.3, ...) Execute instant procedural animation presets: - punch_scale: impact scale pop and overshoot (punch_factor) - shake_2d: screen/node trauma shake with decay (amplitude) - float_bob: looping levitation / idle hover (bob_distance, loops) - fade: alpha fade (target_alpha) - flash_color: flash modulate highlight (flash_color) - progress_fill: smooth bar / gauge value fill (target_value) - bounce_in: drop into place with bounce ease (drop_offset) - spin: rotation spin (revolutions)

• generate_code(target_var="self", property="position", target_value="Vector2(100, 100)", duration=0.5, trans_type="linear", ease_type="in_out", delay=0.0, relative=false) Generate production GDScript Tween code.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Engine Diagnostics, Performance Monitors, and Memory Analysis.

Ops:

• get_monitors() Read active Godot Performance monitors (FPS, process time, physics time, draw calls, object counts, memory, and audio latency).

• get_memory_info() Read detailed static, peak, message buffer, VRAM, and texture memory breakdown.

• get_render_info() Read render pipeline frame statistics (draw calls, primitive count, render objects, VRAM).

• get_physics_info() Read 2D and 3D physics server stats (active bodies, collision pairs, islands).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

DisplayServer Configuration, Window Controls, and SubWindow Scaffolding.

Ops:

• set_mode(mode="windowed", borderless=None, always_on_top=None) Set window mode (windowed, fullscreen, exclusive_fullscreen, maximized, minimized).

• get_display_info() Read active screen dimensions, window geometry, refresh rate, VSync, and mouse mode.

• set_window_rect(size=None, position=None) Resize and reposition the active window.

• set_vsync(vsync_mode="enabled") Configure VSync (disabled, enabled, adaptive, mailbox).

• set_mouse_mode(mouse_mode="visible") Set mouse capture mode (visible, hidden, captured, confined, confined_hidden).

• scaffold_subwindow(parent_path="", window_type="Window", name="SubWindow", title="Window", size=[400, 300], transient=true, exclusive=false) Scaffold a Window, AcceptDialog, or ConfirmationDialog in the scene.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Asynchronous Threaded Resource Loading, Progress Polling, and Loading Screen Scaffolding.

Ops:

• start_load(path, type_hint="", use_sub_threads=false, cache_mode=1) Begin background asynchronous loading of a scene or resource.

• get_status(path) Poll progress percentage (0.0 - 1.0) and status (in_progress, loaded, failed).

• get_resource(path) Retrieve confirmation and metadata for a loaded resource.

• scaffold_loading_screen(save_path="res://scripts/loading_screen.gd") Scaffold a complete asynchronous loading screen script.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

GPU Compute Shaders, RenderingDevice Uniform Buffers, and GPU Pipeline Execution.

Ops:

• create_shader(shader_path="res://shaders/compute_example.glsl", code="") Create a GLSL compute shader template file.

• get_device_info() Inspect RenderingDevice capabilities, workgroup limits, and driver version.

• run_compute(shader_path, input_buffer=[...], x_groups=1, y_groups=1, z_groups=1) Compile and dispatch a compute pipeline on the GPU and read back output data.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Project Export Automation, Presets Inspection, and Headless Game Builds.

Ops:

• list_presets() List all configured platform export targets in export_presets.cfg.

• get_preset_info(preset_name) Inspect detailed build settings and options for a specific preset.

• run_export(preset_name, output_path="", debug=false) Execute a headless project export via Godot CLI.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

AR/VR OpenXR Rigging, Controller Setup, and XRServer Tracking Status.

Ops:

• scaffold_xr_rig(parent_path="", rig_name="XROrigin3D") Scaffold complete OpenXR player hierarchy (origin, camera, left/right controllers).

• get_xr_status() Inspect XRServer active interfaces, tracking status, and OpenXR availability.

• generate_xr_startup_script(save_path="res://scripts/xr_initializer.gd") Generate an OpenXR initialization bootstrap script.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Editor Undo/Redo History Introspection and Transaction Execution.

Ops:

• get_history() Query active action name, undo stack depth, and history IDs.

• undo() Execute an undo action in the active editor.

• redo() Execute a redo action in the active editor.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Path2D/Path3D Curves, Splines, and Patrol Route Automation.

Ops:

• create_curve_2d(points=None, closed=false, save_path="") Create a Curve2D resource with Bezier control points.

• create_curve_3d(points=None, closed=false, save_path="") Create a Curve3D resource with Bezier control points.

• scaffold_path(parent_path="", type="Path3D", name="Path", with_follow=true, loop=true) Scaffold a Path2D or Path3D node with an optional PathFollow child.

• sample_baked_points(path_node_path, interval=1.0) Sample baked positions along a Path2D or Path3D at fixed intervals.

• generate_spline(shape="circle", is_3d=true, radius=5.0, points_count=16, save_path="") Procedurally generate standard spline curves (circle, sine, spiral, rect, s_curve).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Procedural 3D Mesh Synthesis, MeshDataTool Deformation, and Primitive Generation.

Ops:

• generate_surface_mesh(primitive_type="TRIANGLES", vertices=None, normals=None, uvs=None, colors=None, indices=None, generate_normals=false, generate_tangents=false, save_path="", attach_to="") Generate custom ArrayMesh geometry via SurfaceTool.

• deform_mesh(mesh_path, mode="displace", axis="y", factor=1.0, save_path="") Inspect and deform an existing mesh via MeshDataTool.

• create_primitive(primitive="BoxMesh", properties=None, save_path="", attach_to="") Create a configured PrimitiveMesh resource.

• get_mesh_info(mesh_path="", node_path="") Read mesh class, surface count, and AABB dimensions.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

WorldEnvironment, Post-Processing Effects, CameraAttributes, and Lighting Presets.

Ops:

• scaffold_world_environment(parent_path="", sky_mode="procedural", tonemap_mode="aces", name="WorldEnvironment") Scaffold a WorldEnvironment node with sky and tonemapping.

• set_environment_effects(node_path="", glow_enabled=None, glow_intensity=None, ssr_enabled=None, ssao_enabled=None, ssil_enabled=None, sdfgi_enabled=None, volumetric_fog_enabled=None, volumetric_fog_density=None) Configure post-processing and volumetric lighting effects.

• set_camera_attributes(camera_path, attributes_type="practical", auto_exposure_enabled=None, dof_blur_far_enabled=None, dof_blur_far_distance=None) Configure CameraAttributes on a Camera3D node.

• apply_lighting_preset(preset="outdoor_sunny", node_path="") Apply a visual lighting preset to the environment.

• get_environment_info(node_path="") Read active environment properties, background mode, and post-processing toggles.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Skeleton3D Rigging, Bone Transform Inspection, BoneAttachment3D Sockets, and Ragdolls.

Ops:

• get_skeleton_info(skeleton_path="") Inspect bone hierarchy, rest transforms, and pose transforms.

• set_bone_pose(skeleton_path, bone_name, position=None, rotation=None, scale=None) Set position, rotation, or scale for a specific bone.

• scaffold_bone_attachment(skeleton_path, bone_name, name="BoneAttachment3D") Scaffold a BoneAttachment3D node attached to a designated bone.

• scaffold_ragdoll(skeleton_path, collision_layer=1, collision_mask=1, total_mass=70.0) Generate PhysicalBone3D nodes for all bones in a Skeleton3D.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Cryptographic Operations, File/String Checksums, Random Tokens, RSA, and X509 Certificates.

Ops:

• hash_file(file_path, algorithm="sha256") Compute checksum digest of a project file (sha256, sha1, md5).

• hash_string(content, algorithm="sha256") Compute checksum digest of a string (sha256, sha1, md5).

• generate_random_bytes(size=32, format="hex") Generate cryptographically secure random bytes (hex or base64).

• generate_rsa_key(key_size=2048, save_path="") Generate and optionally save an RSA private key.

• generate_self_signed_cert(key_path="", cert_save_path="", common_name="localhost", issuer_name="GodotMCP") Generate a self-signed X509 certificate.

• hmac_digest(key, message, algorithm="sha256") Compute HMAC authentication digest.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

EditorPlugin Discovery, Addon Enable/Disable, and Custom Plugin Scaffolding.

Ops:

• list_plugins(addons_dir="res://addons") Scan res://addons and list all installed editor plugins and statuses.

• set_plugin_enabled(plugin_name, enabled=true) Enable or disable an editor plugin in ProjectSettings.

• scaffold_plugin(plugin_id="my_custom_addon", plugin_name="My Custom Addon", description="A custom Godot EditorPlugin", author="Developer", version="1.0.0", with_dock=true) Generate complete scaffolding for a new custom EditorPlugin.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

PCK Virtual Package Creation, Dynamic Mounting, and Inspection.

Ops:

• create_pck(pck_path, files=[], alignment=32) Pack a list of project resource files into a standalone .pck package.

• load_pck(pck_path, replace_files=True) Dynamically mount a .pck package into the virtual filesystem.

• inspect_pck(pck_path) Check existence and size in bytes of a .pck package.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Operating System Information, Time APIs, Engine Time Scale, Clipboard, and Environment.

Ops:

• get_system_info() Inspect OS name, processor count, device model, video adapter, and locale.

• get_time() Query current Unix epoch, ISO 8601 string, timezone offset, and datetime dict.

• set_time_scale(time_scale=1.0) Accelerate or slow down the game engine time scale.

• get_clipboard() Retrieve text from the system clipboard.

• set_clipboard(text="") Set text into the system clipboard.

• get_env(var_name) Read a process environment variable.

• set_env(var_name, value="") Set a process environment variable.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

2D and 3D Lighting, Shadow Tuning, Decal Projection, and Reflection/GI Probes.

Ops:

• scaffold_light_3d(type="DirectionalLight3D", parent_path="", name="Light3D", color=None, energy=1.0, shadows=True, range=5.0, attenuation=1.0, spot_angle=45.0) Scaffold a DirectionalLight3D, OmniLight3D, or SpotLight3D node.

• scaffold_light_2d(type="PointLight2D", parent_path="", name="Light2D", color=None, energy=1.0, shadows=False) Scaffold a PointLight2D or DirectionalLight2D node.

• scaffold_decal(parent_path="", name="Decal", size=None, texture_albedo="") Scaffold a Decal node with projection volume and albedo texture.

• scaffold_probe(type="ReflectionProbe", parent_path="", name="Probe", size=None) Scaffold a ReflectionProbe, LightmapGI, or VoxelGI node.

• set_light_properties(light_path, color=None, energy=None, shadows=None, volumetric_fog_energy=None) Update lighting parameters on an existing 2D or 3D light node.

• get_light_info(light_path) Inspect light energy, color, and shadow properties.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

In-Engine HTTP Requests, File Downloads, and HTTPRequest Scaffolding.

Ops:

• scaffold_http_request(parent_path="", name="HTTPRequest", timeout=30.0) Scaffold an HTTPRequest node into the scene hierarchy.

• send_request(url, method="GET", headers=[], body="", timeout=10.0) Execute an in-engine REST/HTTP request via Godot's networking stack.

• download_file(url, target_path, timeout=30.0) Download a remote file into the project virtual filesystem (res:// or user://).

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Global Shader Parameters, Uniform Variables, and Project-Wide Shader Settings.

Ops:

• list_globals() List all global shader parameters defined in RenderingServer.

• set_global(name, value) Set or update runtime value of a global shader parameter.

• add_global(name, type="float", value=None) Define a new global shader parameter in ProjectSettings (shader_globals/).

• remove_global(name) Remove a global shader parameter definition.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Viewport Capture, Image Export, and MovieWriter Recording Automation.

Ops:

• capture_viewport(target_path="res://screenshot.png", viewport_path="") Capture current frame from a Viewport and save to PNG.

• configure_movie_writer(movie_file="res://movie.avi", fps=60, quality=0.8) Configure MovieWriter settings in ProjectSettings.

• get_writer_status() Check if MovieWriter mode is active and inspect configured output file.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Texture and Image Resource Management.

Ops:

• create_image(width=64, height=64, use_mipmaps=False, format="rgba8", fill_color=None, save_path="") Create a new Image resource and optionally fill color and save to disk.

• create_atlas(atlas_path, region_rect=[0,0,32,32], filter_clip=False, save_path="") Create an AtlasTexture referencing a region of an existing texture.

• get_texture_info(path) Get metadata for a texture or image resource.

• create_curve_texture(points=[[0.0,0.0],[1.0,1.0]], width=256, save_path="") Create a CurveTexture resource from control points.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Font and Label Styling Management.

Ops:

• create_system_font(font_names=["Sans-Serif"], italic=False, weight=400, save_path="") Create a SystemFont resource and optionally save to disk.

• create_font_variation(base_font_path, variation_embolden=0.0, save_path="") Create a FontVariation resource derived from a base font.

• create_label_settings(font_path="", font_size=16, font_color="#ffffff", outline_size=0, outline_color="#000000", shadow_size=0, shadow_color="#000000", save_path="") Create a LabelSettings resource with font styling options.

• get_font_info(font_path) Inspect metadata and properties of a font resource.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Networking and Socket Scaffolding.

Ops:

• scaffold_tcp_server(parent_path="", port=8080, bind_address="*", node_name="TcpServer") Scaffold a TCP server node in the current scene.

• scaffold_websocket_peer(parent_path="", url="", node_name="WebSocketClient") Scaffold a WebSocket peer node in the current scene.

• scaffold_udp_peer(parent_path="", port=9000, node_name="UdpPeer") Scaffold a UDP packet peer node in the current scene.

• get_network_interfaces() List local network IP addresses and adapter interfaces.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

VisualShader Graph Management.

Ops:

• create_visual_shader(shader_type="spatial", save_path="") Create a new VisualShader resource for spatial, canvas_item, particles, etc.

• add_node(shader_path, node_type="VisualShaderNodeColorConstant", shader_type_enum=0, position=[0,0]) Add a VisualShaderNode into the visual shader graph.

• connect_nodes(shader_path, shader_type_enum=0, from_node=0, from_port=0, to_node=0, to_port=0) Connect two node ports in a VisualShader graph.

• get_graph(shader_path, shader_type_enum=0) Inspect all nodes and connections in a VisualShader graph.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

AnimationTree State Machine and Blend Tree Management.

Ops:

• scaffold_state_machine(parent_path="", anim_player_path="", node_name="AnimationTree") Scaffold an AnimationTree with an AnimationNodeStateMachine root.

• add_state(tree_path, state_name, animation_name="", position=[0,0]) Add an animation state node into an AnimationNodeStateMachine.

• add_transition(tree_path, from_state, to_state, auto_advance=False) Add a transition between two states in an AnimationNodeStateMachine.

• scaffold_blend_tree(parent_path="", anim_player_path="", node_name="AnimationTreeBlend") Scaffold an AnimationTree with an AnimationNodeBlendTree root.

• get_tree_info(tree_path) Inspect root node configuration and status of an AnimationTree.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Sprite, MultiMesh, and Line2D Management.

Ops:

• create_sprite_frames(animations=[{"name":"default","fps":5.0,"loop":true}], save_path="") Create a new SpriteFrames resource with named animations.

• scaffold_animated_sprite(parent_path="", sprite_type="2d", sprite_frames_path="", node_name="AnimatedSprite") Scaffold an AnimatedSprite2D or AnimatedSprite3D in current scene.

• scaffold_multimesh(parent_path="", mesh_type="box", instance_count=100, is_2d=False, node_name="MultiMeshInstance") Scaffold a MultiMeshInstance2D or MultiMeshInstance3D with instances.

• configure_line_2d(node_path, points=[], width=10.0, default_color="#ffffff") Configure points and styling of a Line2D node.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Editor Settings and Configuration Management.

Ops:

• get_setting(setting_name) Get an editor setting value by its configuration key path.

• set_setting(setting_name, value) Set an editor setting value.

• list_settings(prefix="") List available editor setting key paths matching an optional prefix.

• get_editor_paths() Get standard Godot editor directory paths from EditorPaths.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Physics Joints Management (2D and 3D).

Ops:

• scaffold_joint_2d(parent_path="", joint_type="pin", node_a_path="", node_b_path="", node_name="Joint2D") Scaffold a 2D physics joint (pin, groove, damped_spring).

• scaffold_joint_3d(parent_path="", joint_type="pin", node_a_path="", node_b_path="", node_name="Joint3D") Scaffold a 3D physics joint (pin, hinge, slider, cone_twist, generic_6dof).

• configure_joint(joint_path, properties={}) Configure properties and parameters of a physics joint node.

• get_joint_info(joint_path) Inspect connected nodes and properties of a physics joint node.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Occlusion Culling Management.

Ops:

• scaffold_occluder_3d(parent_path="", occluder_type="box", size=[1.0,1.0,1.0], node_name="OccluderInstance3D") Scaffold a 3D occlusion culling node (box, sphere, quad).

• scaffold_occluder_2d(parent_path="", polygon_points=[[-16,-16],[16,-16],[16,16],[-16,16]], closed=True, node_name="LightOccluder2D") Scaffold a 2D light/occlusion polygon node in current scene.

• get_occluder_info(occluder_path) Inspect occluder node and attached occluder resource.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

ConfigFile, JSON, and Expression Utilities.

Ops:

• config_read(file_path, section="", key="") Read values or entire sections from an INI ConfigFile.

• config_write(file_path, section, key, value) Write a section and key value into an INI ConfigFile.

• json_parse(json_string) Parse a JSON string into Godot Variant data structure.

• json_generate(data, indent="") Serialize data into a formatted JSON string.

• expression_eval(expression_string, input_names=[], input_values=[]) Evaluate a mathematical or logic expression via Godot Expression.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Parallax and Canvas Layer Management.

Ops:

• scaffold_parallax(parent_path="", scroll_scale=[1.0,1.0], repeat_size=[0.0,0.0], node_name="Parallax2D") Scaffold a Parallax2D node for background layer scrolling.

• scaffold_canvas_layer(parent_path="", layer=1, follow_viewport=False, node_name="CanvasLayer") Scaffold a CanvasLayer node in the scene tree.

• scaffold_visibility_notifier(parent_path="", is_2d=True, rect_size=[100.0,100.0], node_name="VisibilityNotifier") Scaffold a VisibleOnScreenNotifier2D or 3D node.

• get_parallax_info(node_path) Inspect properties of a parallax or canvas layer node.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Physics Body & Collision Management (2D and 3D).

Ops:

• configure_body(node_path, properties={}) Configure physics parameters of a body (mass, gravity_scale, damping).

• apply_impulse(node_path, impulse=[0,0], position=None) Apply an impulse to a 2D or 3D RigidBody.

• set_collision_layer_mask(node_path, collision_layer=None, collision_mask=None, collision_priority=None) Set collision layers and masks for a 2D or 3D collision object.

• scaffold_character_body(parent_path="", node_name="Player", is_3d=False) Scaffold a CharacterBody2D or CharacterBody3D with collision shape.

• get_body_info(node_path) Inspect collision layers, mass, and properties of a physics body.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

WorldEnvironment, Sky, and Post-Processing Management.

Ops:

• configure_world_environment(node_path="", properties={}) Configure properties of WorldEnvironment and its Environment resource.

• create_sky_material(node_path="", sky_type="procedural", sky_top_color="", ground_bottom_color="", texture_path="") Create and assign procedural or panorama sky material to Environment.

• set_volumetric_fog(node_path="", enabled=True, density=None, albedo=None, emission=None, anisotropy=None, length=None) Enable and configure volumetric fog parameters on Environment.

• configure_camera_attributes(node_path="", attribute_type="practical", properties={}) Configure CameraAttributesPractical or CameraAttributesPhysical.

• get_world_info(node_path="") Inspect active world environment, fog, sky, and post-processing settings.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

AudioServer DSP Bus Effects Management.

Ops:

• add_effect_to_bus(bus_name="Master", effect_class="AudioEffectReverb", at_position=-1, properties={}) Add an AudioEffect to an audio bus at the specified index.

• configure_effect(bus_name="Master", effect_index=0, enabled=None, properties={}) Configure parameters and enable state of an audio bus effect.

• remove_effect(bus_name="Master", effect_index=0) Remove an audio effect from a bus by index.

• list_bus_effects(bus_name="Master") List all audio effects assigned to an audio bus.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Navigation Queries and Spatial Pathfinding Management.

Ops:

• query_path_2d(start=[0,0], end=[0,0], optimize=True) Query 2D navigation path between start and end coordinates.

• query_path_3d(start=[0,0,0], end=[0,0,0], optimize=True) Query 3D navigation path between start and end coordinates.

• scaffold_nav_link(parent_path="", start_position=None, end_position=None, bidirectional=True, is_3d=False, node_name="NavLink") Scaffold a 2D or 3D NavigationLink connecting disjoint navmesh areas.

• scaffold_nav_obstacle(parent_path="", radius=32.0, is_3d=False, node_name="NavObstacle") Scaffold a 2D or 3D NavigationObstacle for avoidance navigation.

• get_nav_map_info(is_3d=False) Inspect navigation map cell size, margins, and properties.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Standalone Headless Engine & CLI Management.

Ops:

• run_script(script_path="", inline_code="") Execute a GDScript file or inline code snippet in headless mode.

• run_headless_scene(scene_path, quit_after_frames=60) Execute a scene headlessly for testing or headless game simulation.

• export_project_cli(preset, output_path, is_debug=False) Trigger a headless project export via Godot CLI preset.

• reimport_assets_cli() Reimport modified assets via a headless editor pass.

• get_engine_info() Inspect Godot engine version, platform, and headless CLI capabilities.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Cloud Bridge and ChatGPT Tunnel Management.

Ops:

• get_tunnel_status() Check cloud tunnel and REST gateway operational status.

• get_action_schema_url(host="http://127.0.0.1:8000") Get OpenAPI schema URL and setup instructions for ChatGPT Custom GPT.

• test_cloud_connection() Test round-trip responsiveness between Godot editor and gateway.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Global Illumination, Decal Projections, and Lighting Probes Management.

Ops:

• create_decal(parent_path="", name="Decal", size=[2.0, 2.0, 2.0], texture_albedo="") Create a Decal node under parent with optional albedo texture and dimensions.

• configure_decal(node_path="", size=None, texture_albedo=None, texture_normal=None, texture_orm=None, emission_energy=None, upper_fade=None, lower_fade=None) Configure properties and PBR textures of an existing Decal node.

• create_reflection_probe(parent_path="", name="ReflectionProbe", size=[20.0, 20.0, 20.0], update_mode="once") Create a ReflectionProbe node for local specular reflections.

• create_voxel_gi(parent_path="", name="VoxelGI", size=[20.0, 20.0, 20.0], subdivide=1) Create a VoxelGI node for real-time indirect lighting and ambient bounce.

• create_lightmap_gi(parent_path="", name="LightmapGI", bounces=3) Create a LightmapGI node for high-performance baked lighting.

• get_gi_info(node_path="") Inspect properties and settings of a Decal, ReflectionProbe, VoxelGI, or LightmapGI.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Input Event Simulation, Macro Replay, and Virtual Actions.

Ops:

• simulate_action(action, pressed=True, strength=1.0) Simulate an input action press or release in the running game or editor.

• simulate_key(key, pressed=True, echo=False, shift=False, ctrl=False, alt=False) Simulate a keyboard key event (e.g. 'W', 'Space', 'Escape', or keycode).

• simulate_mouse_button(button_index=1, pressed=True, position=[0.0, 0.0]) Simulate a mouse button press or release at coordinates (1=Left, 2=Right, 3=Middle).

• simulate_mouse_motion(position=[0.0, 0.0], relative=[0.0, 0.0], velocity=[0.0, 0.0]) Simulate a mouse cursor motion event.

• replay_macro(events=[]) Replay a sequential list of input events for automated gameplay testing.

• get_input_state(action) Inspect whether an input action is pressed and its current strength.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Direct 2D and 3D Physics Space State Raycasts, Point Overlaps, and Shape Queries.

Ops:

• intersect_ray_3d(from_pos=[0.0, 0.0, 0.0], to_pos=[0.0, -10.0, 0.0], collision_mask=0xFFFFFFFF, collide_with_bodies=True, collide_with_areas=False) Cast a ray in 3D world space and return hit position, normal, and collider.

• intersect_ray_2d(from_pos=[0.0, 0.0], to_pos=[0.0, 100.0], collision_mask=0xFFFFFFFF, collide_with_bodies=True, collide_with_areas=False) Cast a ray in 2D world space and return hit position, normal, and collider.

• intersect_point_3d(position=[0.0, 0.0, 0.0], max_results=32, collision_mask=0xFFFFFFFF) Query 3D colliders overlapping a point in world space.

• intersect_point_2d(position=[0.0, 0.0], max_results=32, collision_mask=0xFFFFFFFF) Query 2D colliders overlapping a point in world space.

• intersect_shape_3d(shape_type="sphere", radius=1.0, max_results=32) Query 3D colliders overlapping a shape in world space.

• cast_motion_3d(shape_type="sphere", radius=1.0, motion=[0.0, -1.0, 0.0]) Simulate shape motion to determine safe and unsafe collision fractions.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Curve (1D, 2D, 3D), Splines, Gradients, and Color Ramps Management.

Ops:

• create_curve_1d(points=[[0.0, 0.0], [1.0, 1.0]], min_value=0.0, max_value=1.0, save_path="") Create a 1D interpolation/easing Curve resource.

• create_curve_2d(points=[[0.0, 0.0], [100.0, 100.0]], in_tangents=[], out_tangents=[], save_path="") Create a 2D bezier spline Curve2D resource for paths and animation.

• create_curve_3d(points=[[0.0, 0.0, 0.0], [0.0, 5.0, 10.0]], in_tangents=[], out_tangents=[], save_path="") Create a 3D bezier spline Curve3D resource for 3D paths and rail movement.

• create_gradient(offsets=[0.0, 1.0], colors=["#000000", "#ffffff"], save_path="") Create a multi-stop color ramp Gradient resource.

• create_gradient_texture(gradient_path="", width=256, is_2d=False, height=256, save_path="") Create a GradientTexture1D or GradientTexture2D resource.

• sample_curve(curve_path, offset=0.5) Sample value or baked position on a Curve resource.

• sample_gradient(gradient_path, offset=0.5) Sample RGBA color on a Gradient resource.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.