Godai

Creates a new node in the current scene, with the given properties set. Property values are strings in Godot variant syntax: - String properties take the raw string, with NO extra quotes (e.g. "name": "MyNode") - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)`, `NodePath("../Other")` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - To reference a saved resource: `Resource("res://path/to/file.tres")` - To create an embedded resource: `Object(ClassName, "prop": value, ...)`, e.g. `Object(SphereMesh,"radius":2.0)`, or `Object(SphereMesh)` for one with every property at its default. Do NOT use SubResource() or ExtResource() - those only work inside .tscn files. - Integer enum properties take the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning Like all scene edits, the new node is in-memory until save_scene: call it once you're done editing, or it is lost. Every property is verified by reading it back after setting, like set_node_properties. The node is still created even when a property fails: properties that could not be set, or that ended up with a different value than requested, are reported in 'warnings' (with anything Godot printed in 'output'), and 'node_path' says where the node ended up. Do NOT retry the call over a warning - that would create a second node; fix the property with set_node_properties instead.

Adds a node in the current scene to one or more groups. Like all scene edits, the change is in-memory until save_scene: call it once you're done editing, or it is lost.

Attaches an existing script file to a node in the current scene. The script's base type must be compatible with the node's type. Use create_script first if the script doesn't exist yet. Like all scene edits, the attachment is in-memory until save_scene: call it once you're done editing, or it is lost.

Clears the log messages captured so far, so subsequent get_log_messages calls only return output from after this point. This only affects the captured messages; the editor's own Output panel is untouched.

Closes the Godot editor for the project. The user is asked to confirm first, and the call fails if they decline. A headless editor closes without asking. By default, unsaved changes are saved before closing; pass 'skip_save' as true to discard them instead. If the project is running, it is stopped first.

Connects a signal on one node to a method on another node, in the current scene. Both nodes must be in the current scene. The signal must exist on 'from_node', and the method on 'to_node'. Like all scene edits, the connection is in-memory until save_scene: call it once you're done editing, or it is lost.

Creates a new resource. Does NOT open it automatically. Property values are strings in Godot variant syntax: - String properties take the raw string, with NO extra quotes (e.g. "resource_name": "My Resource") - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - To reference a saved resource: `Resource("res://path/to/file.tres")` - To create an embedded resource: `Object(ClassName, "prop": value, ...)`, e.g. `Object(SphereMesh,"radius":2.0)`, or `Object(SphereMesh)` for one with every property at its default. Do NOT use SubResource() or ExtResource() - those only work inside .tscn files. - Integer enum properties take the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning Every property is verified by reading it back after setting, like set_resource_properties. The resource is still created and saved even when a property fails: properties that could not be set, or that ended up with a different value than requested, are reported in 'warnings' (with anything Godot printed in 'output'). Do NOT retry the call over a warning - the file now exists; fix the property with set_resource_properties instead.

Creates a new scene and opens it in the editor.

Creates a new GDScript file. Does NOT open or attach it. If 'content' is given, it is used as the file's contents. Otherwise, a minimal script extending 'base_class' is generated.

Removes the script attached to a node in the current scene. Like all scene edits, the change is in-memory until save_scene: call it once you're done editing, or it is lost.

Disconnects a previously-connected signal between two nodes in the current scene. Like all scene edits, the change is in-memory until save_scene: call it once you're done editing, or it is lost.

Executes the given GDScript code in the editor, in the context of a Node that is a child of the scene currently being edited. For modifying the current scene, use the other tools when possible. However, if you do use a script to modify the current scene, you MUST use `EditorUndoRedoManager` from `EditorInterface.get_editor_undo_redo()`, and the action name MUST end with "(Godai)". You can find nodes relative to the scene root using `EditorInterface.get_edited_scene_root().get_node_or_null(node_path)`. Two helper methods have been provided: - `func editor_undo_redo_create_node(p_undo_redo: EditorUndoRedoManager, p_parent: Node, p_child: Node) -> void` - `func editor_undo_redo_remove_node(p_undo_redo: EditorUndoRedoManager, p_parent: Node, p_child: Node) -> void` If you are using `EditorUndoRedoManager` to add or remove a node, you MUST call one of those helper methods before calling `commit_action()`. This will add some `add_do_method()` and `add_undo_method()` calls to ensure the changes are synchronized to the live game if the game is running. If the script successfully runs, the output from `print()` will be returned.

Gets information about the scene that is currently opened in the Godot editor.

Gets the tree for the scene that is currently opened in the Godot editor.

Gets settings from the Godot editor itself (the values stored in the global editor configuration, e.g. 'text_editor/behavior/indent/size' or 'text_editor/appearance/whitespace/draw_tabs'). These are editor-wide preferences, not project settings. Pass 'names' to get specific settings by name (returned regardless of whether they match their default). Otherwise, all settings are returned, but only those whose value differs from the default; pass 'include_defaults' as true to also include settings left at their default value. Setting values are strings in Godot variant syntax. Integer enum settings are returned as their option name (e.g. `Nearest` instead of `0`), with a note pointing out the translation; pass 'enums_as_ints' as true to get the raw integer values instead. Settings under 'godai/' are Godai's own configuration and are never returned; only the user can see them, via Editor Settings.

Gets Godai's own settings, which configure Godai itself rather than anything inside the Godot project or editor. Only the settings that can be changed at runtime are included; the rest come from command-line arguments. Use set_godai_settings to change them.

Gets the import settings for an imported asset (e.g. a texture or audio file). Option values are strings in Godot variant syntax.

Gets recent log output from the editor (print() output, warnings, and errors) captured since the editor started. Messages are sorted oldest first. Includes messages from both the editor and games run via `run_project`. Each line is prefixed with the local time it was captured, as '[HH:MM:SS.mmm]', so identical lines from different moments can be told apart.

Gets the groups that nodes in the current scene belong to. The results are returned in 'nodes', keyed by the requested node path.

Gets the values of properties on specific nodes in the current scene. Only properties whose value differs from the node's default are returned; pass 'include_defaults' as true to also include properties left at their default value. Properties that Godot neither saves nor shows in the inspector are left out, since they're derived from other properties (e.g. `global_position` comes from `transform`) or inactive given the node's other properties; ask for one by name (e.g. `MyNode:global_position`) to read it anyway. Property values are strings in Godot variant syntax: - String properties are returned raw, without quotes - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - A property referencing a saved resource is returned as `Resource("res://path/to/file.tres")` - A property holding an embedded resource is summarized as `Object(ClassName)`, e.g. `Object(SphereMesh)` - Integer enum properties are returned as their option name (e.g. `Nearest` instead of `0`), with a note pointing out the translation; pass 'enums_as_ints' as true to get the raw integer values instead To inspect the properties of an embedded resource, append a colon-separated property path to the node path: `MyMesh:mesh` returns the properties of the mesh resource, and `MyMesh:mesh:radius` returns just that value. The per-node results are returned in 'nodes', keyed by the requested node path. If any of the node paths can't be found, an error is returned and no properties are read. If a property path can't be resolved, its value will be an object with an `error` key.

Gets settings from the project (the values stored in 'project.godot', e.g. 'application/config/name' or 'display/window/size/viewport_width'). Pass 'names' to get specific settings by name (returned regardless of whether they match their default). Otherwise, all settings are returned, but only those whose value differs from the default; pass 'include_defaults' as true to also include settings left at their default value. Setting values are strings in Godot variant syntax. Integer enum settings are returned as their option name (e.g. `Nearest` instead of `0`), with a note pointing out the translation; pass 'enums_as_ints' as true to get the raw integer values instead.

Gets the values of properties on a saved resource file (e.g. a .tres file). Only properties whose value differs from the resource's default are returned; pass 'include_defaults' as true to also include properties left at their default value. Properties that Godot neither saves nor shows in the inspector are left out, since they're inactive given the resource's other properties (e.g. `alpha_scissor_threshold` on a material that isn't using alpha scissor); name one in 'properties' to read it anyway. Property values are strings in Godot variant syntax: - String properties are returned raw, without quotes - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - A property referencing another saved resource is returned as `Resource("res://path/to/file.tres")` - A property holding an embedded resource is summarized as `Object(ClassName)`, e.g. `Object(FastNoiseLite)` - Integer enum properties are returned as their option name (e.g. `Nearest` instead of `0`), with a note pointing out the translation; pass 'enums_as_ints' as true to get the raw integer values instead Requested properties may use colon-separated sub-paths to address properties nested inside embedded resources or other properties, e.g. `noise:frequency` or `albedo_color:r`. The results are returned in 'properties', keyed by property name (or requested property path). If a requested property holds an embedded resource (e.g. `noise`), all of that resource's properties are returned for it, instead of just a summary. If a requested property can't be resolved, its value will be an object with an `error` key.

Gets the nodes currently selected in the editor for the current scene. If nothing is selected, 'node_paths' is an empty array.

Instantiates a saved scene (.tscn/.scn) as a child node in the current scene, like adding an instanced scene in the editor. Like all scene edits, the new instance is in-memory until save_scene: call it once you're done editing, or it is lost.

Lists the projects currently open in a Godot editor, which version of Godot each one is open in, and whether that editor is headless.

Lists the Godot projects that are available to open. When the MCP is running with --global, this includes the projects registered in the project manager and those under the project base path. Otherwise, this recursively searches the allowed root paths.

Opens a Godot project in a new Godot editor instance, if it isn't already open. Safe to call first for any project, open or not: one that is already open returns its running editor rather than starting a second one, so there is no need to check with list_open_projects beforehand. An editor that is already open keeps the version of Godot and the headless setting it was started with: headless is ignored for it, and asking for a godot_version it isn't running is an error rather than a silent no-op. Check already_open in the result to see whether an editor was already there.

Opens a resource in the inspector.

Opens a scene in the editor.

Opens a script file in the editor's script editor.

Records in the project which version of Godot it is built with, so that Godai always opens it with that version. This is written to a .godai.json config file in the project, which is meant to be committed, so that everyone working on it opens the same editor.

Reads the contents of a script file. If the script is currently open in the editor, its live (possibly unsaved) buffer is returned and 'open_in_editor' is true. Otherwise the contents are read from disk.

Reimports one or more asset files (e.g. after changing the source file or its import settings). Each path must be an imported asset (i.e. have a .import file). On error, nothing is reimported.

Removes a node in the current scene from one or more groups. Like all scene edits, the change is in-memory until save_scene: call it once you're done editing, or it is lost.

Removes the given node (and all its children) from the current scene. Like all scene edits, the change is in-memory until save_scene: call it once you're done editing, or it is lost.

Restarts the Godot editor for the project. The user is asked to confirm first, and the call fails if they decline. A headless editor restarts without asking. By default, unsaved changes are saved before restarting; pass 'skip_save' as true to discard them instead. If the project is running, it is stopped first.

Runs the project from the editor. 'scene' controls what runs: omit it or use 'main' to run the project's main scene, 'current' to run the scene open in the editor, or a path to run a specific scene file.

Saves the scene currently open in the editor to its file. If the scene has never been saved, use save_scene_as instead.

Saves the scene currently open in the editor to the given path, changing the path of the current scene, such that subsequent save_scene calls would save to the new path.

Saves a script's unsaved changes from the editor to its file. If the script is open in the editor, its current (possibly unsaved) contents are written to disk. If it isn't open, there is nothing to save and this is a no-op.

Changes settings in the Godot editor itself (editor-wide preferences, not project settings). Pass 'settings': a map of setting name (e.g. 'text_editor/behavior/indent/size') to value. Values are strings in Godot variant syntax (e.g. `16`, `true`, `2.0`); a value that isn't valid variant syntax is taken as a raw string. An integer enum setting takes the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning. Setting names must already exist; unknown names are rejected. Pass "create_missing": true to create a setting that doesn't exist yet (e.g. one belonging to a plugin that isn't currently loaded). Every setting is verified by reading it back after setting. Settings are set independently: when one fails, the rest are still applied. Settings that could not be set are reported in 'errors', and settings that ended up with a different value than requested are reported in 'warnings', along with the actual resulting value. Anything Godot printed while setting is returned in 'output'. Some settings only take effect after the editor restarts; changing one returns a warning, and the restart_editor tool can perform the restart. If none of the settings can even be attempted, the call fails and nothing is changed. Use get_editor_settings to see the available setting names and their current values. Settings under 'godai/' are Godai's own configuration and can't be changed; only the user can, via Editor Settings.

Changes Godai's own settings, which configure Godai itself rather than anything inside the Godot project or editor. Only the settings that can be changed at runtime can be set here; the rest come from command-line arguments. Use get_godai_settings to see the current values.

Changes the import settings for an imported asset, and reimports it. Only pass the options you wish to change. Option values are strings in Godot variant syntax (e.g. `2`, `true`, `2.0`); a value that isn't valid variant syntax is taken as a raw string. An unknown option name fails the whole call. On error, nothing is changed. Use get_import_settings to see the available option names and the current importer.

Sets the values of properties on specific nodes in the current scene. Only pass the properties you wish to change. To discover the properties a node supports (and their current values), call get_node_properties with "include_defaults": true. EXAMPLE: {"action": "Move node", "nodes": {"path/to/node": {"position": "Vector2(1, 2)"}}} Property values are strings in Godot variant syntax: - String properties take the raw string, with NO extra quotes (e.g. "text": "Hello") - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)`, `NodePath("../Other")` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - To reference a saved resource: `Resource("res://path/to/file.tres")` - To create an embedded resource: `Object(ClassName, "prop": value, ...)`, e.g. `Object(SphereMesh,"radius":2.0)`, or `Object(SphereMesh)` for one with every property at its default. Do NOT use SubResource() or ExtResource() - those only work inside .tscn files. - Careful: `Object(ClassName)` is also how an existing embedded resource reads back, so passing that in replaces it with a new one, losing whatever it held. - Integer enum properties take the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning Property names may use colon-separated sub-paths to set properties nested inside resources or other properties, e.g. `mesh:radius`, `material:albedo_color`, `position:x`. Note: changing a sub-property of a saved resource (`Resource("res://...")`) affects every scene using that resource. This uses the Godot editor's undo/redo system to set the properties, so as many set operations as possible should be done in a single call, so they can all be undone at once. Like all scene edits, the changes are in-memory until sa…

Changes settings in the project and saves 'project.godot'. Pass 'settings': a map of setting name (e.g. 'display/window/size/viewport_width') to value. Values are strings in Godot variant syntax (e.g. `1280`, `true`, `2.0`); a value that isn't valid variant syntax is taken as a raw string. An integer enum setting takes the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning. Setting names must already exist; unknown names are rejected. Pass "create_missing": true to create new settings, e.g. custom game settings, 'autoload/...', 'input/...', 'shader_globals/...' or 'global_group/...'. A feature-tag override of an existing setting (e.g. 'application/config/name.web') counts as existing, and its value is validated against the base setting. Every setting is verified by reading it back after setting. Settings are set independently: when one fails, the rest are still applied (and saved). Settings that could not be set are reported in 'errors', and settings that ended up with a different value than requested are reported in 'warnings', along with the actual resulting value. Anything Godot printed while setting is returned in 'output'. Some settings only take effect after the editor restarts; changing one returns a warning, and the restart_editor tool can perform the restart. If none of the settings can even be attempted, the call fails and nothing is changed. Use get_project_settings to see the available setting names and their current values.

Sets the values of properties on a saved resource file (.tres or .res), and saves the changes to the file. Only pass the properties you wish to change. To discover the properties a resource supports (and their current values), call get_resource_properties with "include_defaults": true. EXAMPLE: {"action": "Change color", "file_path": "res://thing.tres", "properties": {"albedo_color": "Color(1, 0, 0, 1)"}} Property values are strings in Godot variant syntax: - String properties take the raw string, with NO extra quotes (e.g. "resource_name": "My Resource") - Other types use Godot syntax, e.g. `0.5`, `true`, `Vector2(1, 2)`, `Color(1, 0, 0, 1)` - Packed arrays take a flat list of components, so: `PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)` is two colors (r,g,b,a, r,g,b,a), `PackedVector2Array(1, 2, 3, 4)` is two vectors - To reference another saved resource: `Resource("res://path/to/file.tres")` - To create an embedded resource: `Object(ClassName, "prop": value, ...)`, e.g. `Object(FastNoiseLite,"frequency":0.1)`, or `Object(FastNoiseLite)` for one with every property at its default. Do NOT use SubResource() or ExtResource() - those only work inside .tscn files. - Careful: `Object(ClassName)` is also how an existing embedded resource reads back, so passing that in replaces it with a new one, losing whatever it held. - Integer enum properties take the option name (e.g. `Nearest`) or the integer value; setting one by integer returns a note with the matching option name, and an integer matching no option is still applied, with a warning Property names may use colon-separated sub-paths to set properties nested inside embedded resources or other properties, e.g. `noise:frequency`, `albedo_color:r`. Note: the changes are saved to the file immediately, and affect every scene using the resource. This uses the Godot editor's undo/redo system to set the properties, so as many set operations as possible should be done in a single call, so they can all be undone at once (undo…

Stops the running project, if any.

Removes the version of Godot recorded in the project's .godai.json config file, leaving Godai to work out which version to open it with from the project itself.

Replaces the entire contents of an existing script file. You must read the script with read_script first: this fails if the script has changed since you last read it (or created/wrote it), so you don't overwrite edits you haven't seen. If it fails for that reason, read the script again and reapply your change. If the script is open in the editor, its editor buffer is updated instead of the file on disk (so unsaved edits aren't silently clobbered); 'saved' will be false, and you can call save_script to write it to disk. If it isn't open, the file is written directly and 'saved' is true. Use create_script to make a new script.