# Godai (npm · @snopek-games/godai)

Automate the Godot Engine editor: edit scenes and scripts, run projects, manage engine versions

- Trust score: 93/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- npm · `@snopek-games/godai`: 93/100 (this document), [markdown](https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai.md), [page](https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai)

## Channel facts

- Registry: `npm`
- Package: `@snopek-games/godai`
- Version: `0.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 0 of 5 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to snopek-games/godai).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 13 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 64/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 9738 tokens (~198/item across 49 items; 49 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 5 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 50 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Godai MCP server?

Godai runs locally as an npm package, launched with npx -y @snopek-games/godai. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-snopekgames-godai -- npx -y @snopek-games/godai
```

### Cursor

```json
{
  "mcpServers": {
    "com-snopekgames-godai": {
      "command": "npx",
      "args": [
        "-y",
        "@snopek-games/godai"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-snopekgames-godai": {
      "command": "npx",
      "args": [
        "-y",
        "@snopek-games/godai"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-snopekgames-godai -- npx -y @snopek-games/godai
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-snopekgames-godai": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@snopek-games/godai"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-snopekgames-godai --command npx --arg -y --arg @snopek-games/godai
```

### Hermes

```yaml
mcp_servers:
  com-snopekgames-godai:
    command: "npx"
    args: ["-y", "@snopek-games/godai"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-snopekgames-godai": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@snopek-games/godai"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-snopekgames-godai -t stdio -c npx -a -y @snopek-games/godai
```

### Other

```json
{
  "mcpServers": {
    "com-snopekgames-godai": {
      "command": "npx",
      "args": [
        "-y",
        "@snopek-games/godai"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-21 (score 93, 0)

- [security] Stability: 0.97 → pass

### 2026-09-20 (score 93, +1)

No change was recorded against any check on this day. Stability & Change Management went from 93 to 97. That category is still filling its 30-day observation window: 28 days of observed history at the previous scan, 29 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-18 (score 92, +1)

No change was recorded against any check on this day. Stability & Change Management went from 87 to 90. That category is still filling its 30-day observation window: 26 days of observed history at the previous scan, 27 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-16 (score 91, +1)

No change was recorded against any check on this day. Stability & Change Management went from 80 to 83. That category is still filling its 30-day observation window: 24 days of observed history at the previous scan, 25 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-14 (score 90, +1)

No change was recorded against any check on this day. Stability & Change Management went from 73 to 77. That category is still filling its 30-day observation window: 22 days of observed history at the previous scan, 23 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-12 (score 89, +1)

No change was recorded against any check on this day. Stability & Change Management went from 67 to 70. That category is still filling its 30-day observation window: 20 days of observed history at the previous scan, 21 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-10 (score 88, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63. That category is still filling its 30-day observation window: 18 days of observed history at the previous scan, 19 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-08 (score 87, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (49)

### `open_godot_project` (~257 tokens)

Open Godot Project

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.

Input parameters:

- `godot_version` (string): Open the project with this version of Godot, regardless of the version the project itself asks for, installing it if it isn't installed yet. Use a version from list_installed_godot_versions. Leave th…
- `headless` (boolean): Launch the editor without visual or audio output (default: false)
- `project_path` (string, required): The absolute path to the project directory

Output parameters:

- `already_open` (boolean): True if an editor was already running for this project, in which case headless was ignored and godot_version, if it was given, matched what that editor is running
- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the project was already open, or a new editor instance was started for it

### `list_open_projects` (~39 tokens)

List Open Godot Projects

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

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `projects` (array): The projects that are currently open in a Godot editor

### `get_godai_settings` (~64 tokens)

Get Godai 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.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `godot_version` (string): The version of Godot used by default, as named by list_installed_godot_versions; empty if none is configured
- `project_base_path` (string): The base path where the user's Godot projects live; always empty unless MCP is running with --global
- `update_check` (string): Whether godai checks for its own updates: "on", "off", or empty for the default (on)

### `set_godai_settings` (~149 tokens)

Set Godai 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.

Input parameters:

- `godot_version` (string): The version of Godot to use by default; it must already be installed, which list_installed_godot_versions shows
- `project_base_path` (string): The base path where the user's Godot projects live; can only be set when MCP is running with --global
- `update_check` (string): Whether godai checks for its own updates

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the settings were changed and saved

### `pin_project_to_godot_version` (~111 tokens)

Pin Project to Godot Version

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.

Input parameters:

- `godot_version` (string, required): The version or linked name to pin the project to, which must already be installed
- `project_path` (string, required): The absolute path to the project directory

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `godot_version` (string): The version the project is now pinned to
- `success` (boolean): True if the project was pinned to that version

### `list_projects` (~55 tokens)

List Godot Projects

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.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `projects` (array): The Godot projects that were found

### `unpin_project_from_godot_version` (~63 tokens)

Unpin Project from Godot Version

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.

Input parameters:

- `project_path` (string, required): The absolute path to the project directory

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the project is no longer pinned to a version of Godot
- `was_pinned` (boolean): True if the project was pinned to begin with

### `open_scene` (~64 tokens)

Open Scene

Opens a scene in the editor.

Input parameters:

- `file_path` (string, required): Path to the .tscn file to open, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the scene was opened

### `get_node_properties` (~547 tokens)

Get Node Properties

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.

Input parameters:

- `enums_as_ints` (boolean): Return integer enum properties as their raw integer value, instead of translated to the option name (default: false)
- `include_defaults` (boolean): Also include properties left at their default value (default: false)
- `node_paths` (array, required): The nodes to get properties from
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `nodes` (object): Maps each requested node path to its result.
- `notes` (array): Notes that don't indicate a problem, e.g. which integer enum properties were translated to their option name

### `remove_node` (~93 tokens)

Remove Node

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.

Input parameters:

- `node_path` (string, required): Path to the node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the node was removed

### `save_script` (~107 tokens)

Save Script

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.

Input parameters:

- `file_path` (string, required): Path to the .gd file, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `saved` (boolean): True if the script was open and its contents were written to disk; false if it wasn't open (nothing to save)
- `success` (boolean): True if the operation succeeded

### `read_script` (~99 tokens)

Read Script

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.

Input parameters:

- `file_path` (string, required): Path to the .gd file, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `content` (string): The contents of the script (the live editor buffer if open, otherwise the file on disk)
- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `open_in_editor` (boolean): True if the script is currently open in the editor (so 'content' is the live buffer)

### `run_project` (~143 tokens)

Run Project

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.

Input parameters:

- `clear_log_messages` (boolean): Clear the captured log messages before running, so get_log_messages only returns output from this run onward (default: false)
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `scene` (string): What to run: 'main' (default), 'current', or a path to a scene file

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the project started running

### `clear_log_messages` (~73 tokens)

Clear Log Messages

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.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the captured log messages were cleared

### `attach_script` (~136 tokens)

Attach Script

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.

Input parameters:

- `node_path` (string, required): Path to the node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `script_path` (string, required): Path to the script file, relative to the project root

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the script was attached

### `open_script` (~67 tokens)

Open Script

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

Input parameters:

- `file_path` (string, required): Path to the .gd file to open, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the script was opened in the script editor

### `set_project_settings` (~415 tokens)

Set Project Settings

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.

Input parameters:

- `create_missing` (boolean): Allow creating settings that don't exist yet; without it, unknown setting names are rejected
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `settings` (object, required): Settings to set (keys are setting names)

Output parameters:

- `errors` (array): When the call failed, the errors that made it fail (nothing was changed). Otherwise, settings that could not be set; any setting not listed here or in 'warnings' was set to the requested value
- `notes` (array): Notes that don't indicate a problem, e.g. the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the settings were being set
- `success` (boolean): True if every setting was verified to have taken the requested value and the project was saved (a setting that only triggered a warning still counts as success)
- `warnings` (array): Settings that were changed, but ended up with a different value than requested, or that require an editor restart to take effect

### `set_node_properties` (~789 tokens)

Set Node Properties

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…

Input parameters:

- `action` (string, required): Human-readable description of the action that will be shown in Godot's undo/redo history
- `nodes` (object, required): Keys are the paths of the nodes to change, within the scene and relative to its root. A key may include a colon-separated property path (e.g. `MyMesh:mesh`) to address a resource or other sub-object.
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): When the call failed, the errors that made it fail (nothing was changed). Otherwise, properties that could not be set; any property not listed here or in 'warnings' was set to the requested value
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene, or the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the properties were being set
- `success` (boolean): True if every property was verified to have taken the requested value (a property that only triggered a warning still counts as success)
- `warnings` (array): Properties that were changed, but ended up with a different value than requested

### `set_resource_properties` (~755 tokens)

Set Resource Properties

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…

Input parameters:

- `action` (string, required): Human-readable description of the action that will be shown in Godot's undo/redo history
- `file_path` (string, required): Path to the .tres or .res file, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `properties` (object): Keys are the Godot property names to set (colon-separated sub-paths allowed, e.g. `albedo_color:r`)

Output parameters:

- `errors` (array): When the call failed, the errors that made it fail (nothing was changed). Otherwise, properties that could not be set; any property not listed here or in 'warnings' was set to the requested value
- `notes` (array): Notes that don't indicate a problem, e.g. the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the properties were being set
- `success` (boolean): True if every property was verified to have taken the requested value (a property that only triggered a warning still counts as success)
- `warnings` (array): Properties that were changed, but ended up with a different value than requested

### `connect_signal` (~177 tokens)

Connect Signal

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.

Input parameters:

- `from_node` (string, required): Path to the node emitting the signal, relative to the scene root
- `method` (string, required): Name of the method to call on the receiving node
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `signal` (string, required): Name of the signal to connect
- `to_node` (string, required): Path to the node receiving the signal, relative to the scene root

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the signal was connected

### `get_log_messages` (~139 tokens)

Get Log Messages

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.

Input parameters:

- `count` (integer): Maximum number of recent messages to return (default: 100). Use 0 for all retained messages.
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `messages` (array): The most recent log lines, oldest first

### `create_resource` (~470 tokens)

Create Resource

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.

Input parameters:

- `file_path` (string, required): Path to the .tres file to create, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `properties` (object): Keys are the Godot property names to set
- `resource_type` (string, required): The resource type

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did, in which case the resource was NOT created
- `notes` (array): Notes that don't indicate a problem, e.g. the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the resource was being created
- `success` (boolean): True if the resource was created and saved; property problems are reported in 'warnings' and do not affect this - do NOT retry the call for them, fix them with set_resource_properties instead
- `warnings` (array): Properties that could not be set, or ended up with a different value than requested; any property not listed here was set to the requested value

### `get_selected_nodes` (~62 tokens)

Get Selected Nodes

Gets the nodes currently selected in the editor for the current scene.

If nothing is selected, 'node_paths' is an empty array.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `node_paths` (array): Paths of the selected nodes, relative to the scene root

### `save_scene` (~60 tokens)

Save Scene

Saves the scene currently open in the editor to its file.

If the scene has never been saved, use save_scene_as instead.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `scene_path` (string): The path the scene was saved to
- `success` (boolean): True if the scene was saved

### `remove_from_group` (~106 tokens)

Remove Node from Groups

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.

Input parameters:

- `groups` (array, required): The groups to remove the node from
- `node_path` (string, required): Path to the node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the node was removed from the groups

### `disconnect_signal` (~145 tokens)

Disconnect Signal

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.

Input parameters:

- `from_node` (string, required): Path to the node emitting the signal, relative to the scene root
- `method` (string, required): Name of the connected method on the receiving node
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `signal` (string, required): Name of the signal to disconnect
- `to_node` (string, required): Path to the node receiving the signal, relative to the scene root

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the signal was disconnected

### `get_editor_settings` (~305 tokens)

Get Editor Settings

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.

Input parameters:

- `enums_as_ints` (boolean): Return integer enum settings as their raw integer value, instead of translated to the option name (default: false)
- `include_defaults` (boolean): When getting all settings, also include those left at their default value (default: false)
- `names` (array): Specific setting names to get. If omitted, all settings are returned.
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. which integer enum settings were translated to their option name
- `settings` (object): A map of setting name to value, in Godot variant syntax

### `restart_editor` (~126 tokens)

Restart Editor

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.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `skip_save` (boolean): Discard unsaved changes instead of saving them before restarting (default: false)

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True once the editor has restarted and reconnected

### `get_current_scene_tree` (~52 tokens)

Get Scene Tree

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

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `children` (array): The child nodes; omitted if the node has no children
- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `name` (string): The Node name
- `path` (string): The path of the node within the scene, relative to the scene root
- `script` (string): The path to the script file, if this node has a script attached; otherwise omitted
- `type` (string): The class of the Node

### `detach_script` (~90 tokens)

Detach Script

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.

Input parameters:

- `node_path` (string, required): Path to the node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the script was detached

### `add_to_group` (~106 tokens)

Add Node to Groups

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.

Input parameters:

- `groups` (array, required): The groups to add the node to
- `node_path` (string, required): Path to the node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the node was added to the groups

### `create_script` (~146 tokens)

Create Script

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.

Input parameters:

- `base_class` (string): Base class for the generated script when 'content' is omitted (default: Node)
- `content` (string): Full contents of the script file. If omitted, a minimal template is generated.
- `file_path` (string, required): Path to the .gd file to create, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the script file was created

### `write_script` (~220 tokens)

Write Script

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.

Input parameters:

- `content` (string, required): The full new contents of the script, which may be empty to blank the script out
- `file_path` (string, required): Path to the .gd file, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. that the script has unsaved changes until save_script
- `open_in_editor` (boolean): True if the script was open, so its editor buffer was updated rather than the file on disk
- `saved` (boolean): True if the new contents were written to disk; false if only the editor buffer was updated (call save_script to flush it)
- `success` (boolean): True if the script was written

### `close_editor` (~125 tokens)

Close Editor

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.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `skip_save` (boolean): Discard unsaved changes instead of saving them before closing (default: false)

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True once the user has accepted and the editor is closing

### `get_resource_properties` (~575 tokens)

Get Resource Properties

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.

Input parameters:

- `enums_as_ints` (boolean): Return integer enum properties as their raw integer value, instead of translated to the option name (default: false)
- `file_path` (string, required): Path to the resource file, relative to the project root
- `include_defaults` (boolean): Also include properties left at their default value (default: false)
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `properties` (array): The properties to get. If omitted, all of the resource's properties are returned.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. which integer enum properties were translated to their option name
- `properties` (object): If 'properties' was omitted, a map of all the resource's property names to values. If 'properties' was given, a map of each requested property path to its result.

### `instantiate_scene` (~145 tokens)

Instantiate Scene

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.

Input parameters:

- `name` (string): Name for the new instance node
- `parent_path` (string): Path to the parent node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `scene_path` (string, required): Path to the scene file to instantiate, relative to the project root

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `node_path` (string): The path of the new instance node, relative to the scene root
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene
- `success` (boolean): True if the scene was instantiated

### `save_scene_as` (~93 tokens)

Save Scene As

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.

Input parameters:

- `file_path` (string, required): Path to the .tscn file to save to, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `scene_path` (string): The path the scene was saved to
- `success` (boolean): True if the scene was saved

### `get_node_groups` (~77 tokens)

Get Node Groups

Gets the groups that nodes in the current scene belong to.

The results are returned in 'nodes', keyed by the requested node path.

Input parameters:

- `node_paths` (array, required): The nodes to get the groups of
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `nodes` (object): Maps each requested node path to an array of its group names (internal engine groups omitted).

### `get_import_settings` (~82 tokens)

Get Import Settings

Gets the import settings for an imported asset (e.g. a texture or audio file).

Option values are strings in Godot variant syntax.

Input parameters:

- `file_path` (string, required): Path to the imported asset, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `importer` (string): The name of the importer used for this asset
- `options` (object): A map of import option names to values, in Godot variant syntax

### `set_import_settings` (~177 tokens)

Set Import Settings

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.

Input parameters:

- `file_path` (string, required): Path to the imported asset, relative to the project root
- `importer` (string): Change the importer used for this asset
- `options` (object): Import options to set (keys are option names)
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the import settings were changed and the asset was reimported

### `set_editor_settings` (~401 tokens)

Set Editor Settings

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.

Input parameters:

- `create_missing` (boolean): Allow creating settings that don't exist yet; without it, unknown setting names are rejected
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `settings` (object, required): Settings to set (keys are setting names)

Output parameters:

- `errors` (array): When the call failed, the errors that made it fail (nothing was changed). Otherwise, settings that could not be set; any setting not listed here or in 'warnings' was set to the requested value
- `notes` (array): Notes that don't indicate a problem, e.g. the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the settings were being set
- `success` (boolean): True if every setting was verified to have taken the requested value (a setting that only triggered a warning still counts as success)
- `warnings` (array): Settings that were changed, but ended up with a different value than requested, or that require an editor restart to take effect

### `get_current_scene` (~50 tokens)

Get Current Scene

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

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `root_node_name` (string): The name of the root Node
- `root_node_type` (string): The class of the root Node
- `scene_path` (string): The path to the scene file, or '[unsaved]' for a never-saved scene

### `create_scene` (~86 tokens)

Create Scene

Creates a new scene and opens it in the editor.

Input parameters:

- `file_path` (string, required): Path to the .tscn file to create, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `root_node_type` (string, required): The node type of the scene's root node

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the scene was created and opened

### `add_node` (~521 tokens)

Add Node

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.

Input parameters:

- `node_type` (string, required): The name of the node class to create
- `parent_path` (string): Path to the parent node, relative to the scene root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.
- `properties` (object): Keys are the Godot property names to set

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did, in which case the node was NOT created
- `node_path` (string): The path of the new node, relative to the scene root
- `notes` (array): Notes that don't indicate a problem, e.g. that the scene has unsaved changes until save_scene, or the option name matching an integer enum value that was set
- `output` (array): Messages Godot printed while the node was being created
- `success` (boolean): True if the node was created; property problems are reported in 'warnings' and do not affect this - do NOT retry the call for them, fix them with set_node_properties instead
- `warnings` (array): Properties that could not be set, or ended up with a different value than requested; any property not listed here was set to the requested value

### `open_resource` (~64 tokens)

Open Resource

Opens a resource in the inspector.

Input parameters:

- `file_path` (string, required): Path to the .tres file to open, relative to the project root
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the resource was opened in the inspector

### `stop_project` (~42 tokens)

Stop Project

Stops the running project, if any.

Input parameters:

- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True (the running project, if any, was stopped)

### `reimport` (~94 tokens)

Reimport Assets

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.

Input parameters:

- `file_paths` (array, required): The assets to reimport
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `success` (boolean): True if the assets were reimported

### `execute_editor_script` (~341 tokens)

Execute Editor Script

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.

Input parameters:

- `code` (string, required): A snippet of GDScript code. It should use tabs rather than spaces for indentation. Don't wrap the code in a `_ready()` function.
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `output` (array): The lines printed by the script via print()
- `success` (boolean): True if the script ran successfully

### `get_project_settings` (~258 tokens)

Get Project Settings

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.

Input parameters:

- `enums_as_ints` (boolean): Return integer enum settings as their raw integer value, instead of translated to the option name (default: false)
- `include_defaults` (boolean): When getting all settings, also include those left at their default value (default: false)
- `names` (array): Specific setting names to get. If omitted, all settings are returned.
- `project_path` (string): The path to the Godot project. It must already be open in the Godot editor.

Output parameters:

- `errors` (array): The errors that caused the call to fail; present instead of the other properties when it did
- `notes` (array): Notes that don't indicate a problem, e.g. which integer enum settings were translated to their option name
- `settings` (object): A map of setting name to value, in Godot variant syntax

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai#diagnostics

## Score history

- 2026-09-21: 93
- 2026-09-20: 93
- 2026-09-19: 92
- 2026-09-18: 92
- 2026-09-17: 91
- 2026-09-16: 91
- 2026-09-15: 90
- 2026-09-14: 90
- 2026-09-13: 89
- 2026-09-12: 89
- 2026-09-11: 88
- 2026-09-10: 88
- 2026-09-09: 87
- 2026-09-08: 87
- 2026-09-07: 86
- 2026-09-06: 86
- 2026-09-05: 86
- 2026-09-04: 85
- 2026-09-03: 85
- 2026-09-02: 84
- 2026-09-01: 84
- 2026-08-31: 83
- 2026-08-30: 79
- 2026-08-29: 79
- 2026-08-28: 79
- 2026-08-27: 79
- 2026-08-26: 79
- 2026-08-25: 77
- 2026-08-24: 77
- 2026-08-23: 77

## Common questions

### What is the Godai MCP server?

Godai is an MCP server listed in the public MCP registry as com.snopekgames/godai. Automate the Godot Engine editor: edit scenes and scripts, run projects, manage engine versions. This page covers its npm package (@snopek-games/godai).

### Is the Godai MCP server safe to use?

Godai scores 93 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 September 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Godai MCP server expose?

Godai exposes 49 tools: open_godot_project, list_open_projects, get_godai_settings, set_godai_settings, pin_project_to_godot_version, and 44 more. Their descriptions and schemas cost roughly 9,361 tokens of context every time the server is loaded.

### Is the Godai MCP server still maintained?

Godai is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Godai MCP server under?

Godai declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@snopek-games/godai
- Socket report: https://socket.dev/npm/package/@snopek-games/godai
- Repository: https://gitlab.com/snopek-games/godai
- Website: https://godai.sh/
- Changelog RSS feed: https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai.json
- HTML version of this page: https://verifymcp.io/servers/com-snopekgames-godai/snopek-games-godai