Godot MCP

https://github.com/youssof20/godot-mcp
Admin
Godot 4 MCP server for AI assistants, allowing them to read and edit Godot projects through the open...
Tokens:49,470
Snippets:604
Trust Score:5.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Search Files Usage Examples

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Examples demonstrating how to search for files by extension and by name using the client tool interface.

```typescript
// Find all GDScript files
const scripts = await client.callTool("search_files", {
  query: "*.gd",
  extensions: [".gd"]
});

console.log(`Found ${scripts.length} scripts`);
scripts.forEach(s => console.log(s.path));

// Find files by name
const playerFiles = await client.callTool("search_files", {
  query: "player",
  path: "res://",
  max_results: 50
});

playerFiles.forEach(f => console.log(f.path));
```

--------------------------------

### start()

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/01-godot-client-api.md

Initiates connection to the Godot editor plugin.

```APIDOC
## start()

### Description
Initiates connection to the Godot editor plugin. If already connected, returns immediately.

### Returns
- **Promise<void>** - Resolves when connected or rejects if connection fails.

### Throws
- **GodotMcpError** - Throws with code `GODOT_NOT_CONNECTED` if the plugin is unreachable or disabled.
```

--------------------------------

### Call list_available_tools Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

Example usage of the list_available_tools tool via the client.

```typescript
const result = await client.callTool("list_available_tools", {});

console.log(`${result.count} tools are available`);
console.log(`First 5: ${result.tools.slice(0, 5).join(", ")}`);

// Verify Godot and TypeScript are in sync
if (result.tools.length !== result.typescript_registered.length) {
  console.warn("Tool list mismatch between Godot and TypeScript");
}
```

--------------------------------

### Call get_tool_help Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

Example usage of the get_tool_help tool for single and multiple tool queries.

```typescript
// Get help for a single tool
const toolHelp = await client.callTool("get_tool_help", {
  tool: "get_project_info"
});

console.log(`${toolHelp.name}: ${toolHelp.description}`);
console.log(`Category: ${toolHelp.category}`);

// List all tools with help
const allHelp = await client.callTool("get_tool_help", {});
console.log(`${allHelp.length} tools available`);

allHelp.forEach(tool => {
  console.log(`- ${tool.name} (${tool.category})`);
});
```

--------------------------------

### Connect Signal Usage Examples

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/08-node-tools-reference.md

Examples demonstrating how to connect UI button signals and timer timeouts using the client tool call.

```typescript
// Connect button pressed to a method
await client.callTool("connect_signal", {
  source_path: "Root/UI/Button",
  signal: "pressed",
  target_path: "Root/Game",
  method: "_on_button_pressed"
});

// Connect timer timeout
await client.callTool("connect_signal", {
  source_path: "Root/Timer",
  signal: "timeout",
  target_path: "Root/GameManager"
});
```

--------------------------------

### Example log output

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/02-mcp-server-entry-point.md

Standard output generated during the server startup sequence.

```text
[godot-mcp] Starting godot-mcp v0.2.0 (port 6505)
[godot-mcp] Connecting to ws://127.0.0.1:6505 ...
[godot-mcp] Connected to Godot at ws://127.0.0.1:6505
[godot-mcp] Tool mode: full; registering 172 working tool(s)
[godot-mcp] MCP stdio transport ready
```

--------------------------------

### Configure Cursor MCP

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/10-types-and-configuration.md

Example configuration for the .cursor/mcp.json file to set environment variables.

```json
{
  "mcpServers": {
    "godot-mcp": {
      "command": "node",
      "args": ["C:/dev/godot-mcp/dist/index.js"],
      "env": {
        "GODOT_MCP_PORT": "6505",
        "GODOT_MCP_MODE": "lite",
        "GODOT_MCP_TIMEOUT_MS": "60000",
        "ALLOW_GODOT_MCP_DANGEROUS": "1"
      }
    }
  }
}
```

--------------------------------

### Retrieve project settings via client

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Examples for fetching specific settings by key or all settings by prefix.

```typescript
// Get specific settings
const settings = await client.callTool("get_project_settings", {
  keys: [
    "application/config/name",
    "application/config/version",
    "physics/2d/default_gravity"
  ]
});

console.log(`Project: ${settings["application/config/name"]}`);
console.log(`Gravity: ${settings["physics/2d/default_gravity"]}`);

// Get all physics settings
const physicsSettings = await client.callTool("get_project_settings", {
  prefix: "physics/"
});

Object.entries(physicsSettings).forEach(([key, value]) => {
  console.log(`${key}: ${value}`);
});
```

--------------------------------

### Build TypeScript Server

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/TESTING.md

Commands to install dependencies and compile the TypeScript server.

```powershell
cd C:\dev\godot-mcp
npm install
npm run build
```

--------------------------------

### play_scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/11-runtime-and-testing-tools-reference.md

Starts playing the game from a specified scene or the currently edited scene.

```APIDOC
## play_scene

### Description
Starts playing the game from a specified scene or the currently edited scene.

### Signature
`play_scene(params: PlaySceneParams) -> { ok: true; started_at: string }`

### Parameters
- **scene_path** (string) - Optional - res:// path to scene to play

### Returns
- **ok** (boolean) - Success status
- **started_at** (string) - ISO 8601 timestamp

### Throws
- **NOT_FOUND**: scene_path doesn't exist
- **SCENE_ERROR**: Scene file is corrupted

### Example
```typescript
await client.callTool("play_scene", {
  scene_path: "res://main.tscn"
});
```
```

--------------------------------

### Get Tool Help All Return Structure

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

The return structure for requesting help for all tools.

```typescript
ToolHelpMetadata[]  // Array of help objects, one per tool
```

--------------------------------

### Start Connection

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/01-godot-client-api.md

Initiates a connection to the Godot editor plugin. Use a try-catch block to handle potential connection failures.

```typescript
try {
  await client.start();
  console.log("Connected to Godot");
} catch (error) {
  console.error("Connection failed:", error.message);
}
```

--------------------------------

### Call set_anchor_preset tool

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/08-node-tools-reference.md

Examples for configuring UI layout using anchor presets via the set_anchor_preset tool.

```typescript
// Stretch to fill parent
await client.callTool("set_anchor_preset", {
  node_path: "Root/UI/Panel",
  preset: "full_rect"
});

// Center preset
await client.callTool("set_anchor_preset", {
  node_path: "Root/UI/CenterButton",
  preset: 15  // Or preset name
});
```

--------------------------------

### Start a game scene with play_scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/11-runtime-and-testing-tools-reference.md

Initiates the game from a specific scene path or the currently edited scene.

```typescript
await client.callTool("play_scene", {
  scene_path: "res://main.tscn"
});

console.log("Game started playing");
```

--------------------------------

### Execute batch_set_property example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Demonstrates updating the visible property for multiple nodes simultaneously.

```typescript
// Hide all enemy nodes
const result = await client.callTool("batch_set_property", {
  nodes: ["Root/Enemy1", "Root/Enemy2", "Root/Enemy3"],
  property: "visible",
  value: false
});

console.log(`Updated ${result.updated} nodes`);
```

--------------------------------

### Example JSON Request with Parameters

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

A JSON request message including specific parameters for the tool method.

```json
{
  "id": "550e8400-e29b-41d4-a716-446655440001",
  "method": "get_scene_tree",
  "params": {
    "scene_path": "res://main.tscn",
    "max_depth": 5
  }
}
```

--------------------------------

### Get Resource Preview

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Generates a base64-encoded thumbnail image for a given resource.

```typescript
get_resource_preview(params: PreviewParams) -> { 
  image: string; 
  width: number; 
  height: number 
}
```

```typescript
{
  image: string;  // Base64 PNG
  width: number;
  height: number;
}
```

--------------------------------

### Call add_resource tool

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/08-node-tools-reference.md

Examples for assigning textures and materials to nodes using the add_resource tool.

```typescript
// Assign texture to sprite
await client.callTool("add_resource", {
  node_path: "Root/Player/Sprite",
  property: "texture",
  resource_path: "res://assets/player.png"
});

// Assign material
await client.callTool("add_resource", {
  node_path: "Root/Mesh",
  property: "material",
  resource_path: "res://materials/shiny.tres"
});
```

--------------------------------

### Register a tool using registerGodotTool

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/05-tool-categories-overview.md

Example usage of the registerGodotTool helper to register the get_project_info tool.

```typescript
registerGodotTool(
  server,
  client,
  enabled,
  "get_project_info",
  "Get Godot project name, paths, version, and main scene.",
  projectToolSchemas.get_project_info.shape  // Zod schema
);
```

--------------------------------

### Get Tool Help Signature

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

The signature for the get_tool_help function.

```typescript
get_tool_help(tool?: string) -> ToolHelpMetadata | ToolHelpMetadata[]
```

--------------------------------

### get_resource_preview

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Gets a thumbnail image of a resource.

```APIDOC
## get_resource_preview

### Description
Gets a thumbnail image of a resource.

### Parameters
- **resource_path** (string) - Required - res:// path to resource

### Returns
- **image** (string) - Base64 PNG
- **width** (number) - Image width
- **height** (number) - Image height
```

--------------------------------

### Success Response JSON Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

A sample JSON payload representing a successful response.

```json
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "ok": true,
  "result": {
    "project_name": "MyGame",
    "godot_version": "4.4.0",
    "main_scene": "res://main.tscn"
  }
}
```

--------------------------------

### List Scripts Usage Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Demonstrates how to call the list_scripts tool to retrieve all scripts or filter by path, extension, and result count.

```typescript
// List all scripts
const all = await client.callTool("list_scripts", {});
console.log(`Found ${all.count} scripts`);

// List scripts in a folder
const playerScripts = await client.callTool("list_scripts", {
  path: "res://scripts/player",
  extensions: [".gd"],
  max_results: 100
});

playerScripts.scripts.forEach(script => console.log(script));
```

--------------------------------

### assert_node_state Signature, Return, and Usage

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/11-runtime-and-testing-tools-reference.md

Verifies node properties and provides an example of calling the tool via the client.

```typescript
assert_node_state(params: AssertNodeParams) -> { 
  passed: boolean; 
  message: string 
}
```

```typescript
{
  passed: boolean;
  message: string;
}
```

```typescript
const result = await client.callTool("assert_node_state", {
  node_path: "Root/Player",
  expected_properties: {
    visible: true,
    health: 100
  }
});

if (result.passed) {
  console.log("Assertion passed");
} else {
  console.error(result.message);
}
```

--------------------------------

### validate_script Usage Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Demonstrates validating a file by path and validating raw string content.

```typescript
// Validate a file
const result1 = await client.callTool("validate_script", {
  script_path: "res://player.gd"
});

if (result1.valid) {
  console.log("Script is valid");
} else {
  console.error("Errors:", result1.errors);
  console.warn("Warnings:", result1.warnings);
}

// Validate code before writing
const newCode = `
extends Node2D

func _ready()
    print("Missing colon")  # Error: missing colon
`;

const result2 = await client.callTool("validate_script", {
  content: newCode
});

console.log(`Valid: ${result2.valid}`);
if (!result2.valid) {
  result2.errors?.forEach(err => console.error(err));
}
```

--------------------------------

### Example JSON Request

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

A standard JSON request message sent over the WebSocket connection.

```json
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "method": "get_project_info",
  "params": {}
}
```

--------------------------------

### Get Tool Help Single Return Structure

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

The return structure for a single tool help request.

```typescript
{
  name: string;           // Tool name
  category: string;       // Category (e.g., "Server", "Project")
  description: string;    // Short description
  signature?: string;     // Optional parameter info
  examples?: string[];    // Optional usage examples
}
```

--------------------------------

### Type Guard Usage

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

Example of using the type guard to safely narrow response types in TypeScript.

```typescript
const parsed = JSON.parse(raw) as GodotResponse;

if (isGodotErrorResponse(parsed)) {
  // TypeScript now knows: parsed is GodotErrorResponse
  const code = parsed.error.code;
} else {
  // TypeScript now knows: parsed is GodotSuccessResponse
  const result = parsed.result;
}
```

--------------------------------

### Get project statistics signature and usage

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Retrieves aggregate project statistics and demonstrates how to call the tool via the client.

```typescript
get_project_statistics() -> { 
  statistics: ProjectStats 
}
```

```typescript
{
  statistics: {
    total_scenes: number;
    total_scripts: number;
    total_resources: number;
    total_nodes: number;
    average_scene_complexity: number;
    largest_scene: { path: string; nodes: number };
  };
}
```

```typescript
const stats = await client.callTool("get_project_statistics", {});

console.log(`Scenes: ${stats.statistics.total_scenes}`);
console.log(`Scripts: ${stats.statistics.total_scripts}`);
console.log(`Avg complexity: ${stats.statistics.average_scene_complexity}`);
```

--------------------------------

### Build the Node MCP server

Source: https://github.com/youssof20/godot-mcp/blob/main/README.md

Commands to clone the repository and build the Node.js server.

```powershell
git clone https://github.com/youssof20/godot-mcp.git
cd godot-mcp
npm install
npm run build
```

--------------------------------

### Initialize GodotClient

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/01-godot-client-api.md

Instantiate the client with custom port and timeout settings.

```typescript
const client = new GodotClient({ port: 6505, timeoutMs: 30000 });
```

--------------------------------

### Create and populate a scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/00-README.md

Demonstrates the sequence of tool calls required to create a new scene, add nodes, set properties, attach a script, and save the scene.

```typescript
// 1. Create a new scene
await client.callTool("create_scene", {
  scene_path: "res://level_01.tscn",
  root_type: "Node2D",
  root_name: "Level"
});

// 2. Add nodes to it
await client.callTool("open_scene", { scene_path: "res://level_01.tscn" });
await client.callTool("add_node", {
  node_type: "Sprite2D",
  node_name: "Player",
  parent_path: "Level"
});

// 3. Set properties
await client.callTool("update_property", {
  node_path: "Level/Player",
  property: "position",
  value: { x: 100, y: 100 }
});

// 4. Add a script
await client.callTool("create_script", {
  script_path: "res://scripts/player.gd",
  extends_class: "Sprite2D",
  attach_to_node: true,
  node_path: "Level/Player"
});

// 5. Save
await client.callTool("save_scene", {});
```

--------------------------------

### Error Response JSON Example

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

A sample JSON payload representing an error response.

```json
{
  "id": "550e8400-e29b-41d4-a716-446655440001",
  "ok": false,
  "error": {
    "code": "NOT_FOUND",
    "message": "Scene 'res://nonexistent.tscn' not found",
    "suggestion": "Verify the scene file exists in the project",
    "details": {
      "scene_path": "res://nonexistent.tscn"
    }
  }
}
```

--------------------------------

### Run project tests

Source: https://github.com/youssof20/godot-mcp/blob/main/README.md

Commands to verify the tool integration and project phases.

```powershell
npm run test:tools    # 172 tools
npm run test:phase11
```

--------------------------------

### Get Request Timeout

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/10-types-and-configuration.md

Retrieves the request timeout in milliseconds from the GODOT_MCP_TIMEOUT_MS environment variable.

```typescript
function getRequestTimeoutMs(): number
```

```typescript
const timeoutMs = getRequestTimeoutMs();
console.log(`Request timeout: ${timeoutMs}ms`);

// Set longer timeout for slower systems
// GODOT_MCP_TIMEOUT_MS=60000
```

--------------------------------

### Inspect a project

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Tools for retrieving project information and structure. Read-only tools support optional scene_path parameters.

```text
get_project_info
get_filesystem_tree
get_scene_tree          # edited scene, or pass scene_path
get_node_properties
```

--------------------------------

### Get Godot Port

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/10-types-and-configuration.md

Retrieves the configured WebSocket port from the GODOT_MCP_PORT environment variable.

```typescript
function getGodotPort(): number
```

```typescript
const port = getGodotPort();
console.log(`Connecting to Godot on port ${port}`);
```

--------------------------------

### GodotClient(options?)

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/01-godot-client-api.md

Constructor for creating a new GodotClient instance to manage the WebSocket connection.

```APIDOC
## Constructor

### GodotClient(options?)

### Description
Creates a new WebSocket client instance to connect to the Godot editor plugin.

### Parameters
- **options.port** (number) - Optional - WebSocket port for the Godot plugin (Default: 6505)
- **options.host** (string) - Optional - WebSocket hostname (Default: 127.0.0.1)
- **options.timeoutMs** (number) - Optional - Request timeout in milliseconds (Default: 30000)

### Example
```typescript
const client = new GodotClient({ port: 6505, timeoutMs: 30000 });
```
```

--------------------------------

### Create and attach script pattern

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Demonstrates the sequence of creating a new script file and attaching it to a specific node in the scene tree.

```typescript
// Create a script and attach it to a node
await client.callTool("create_script", {
  script_path: "res://scripts/new_behavior.gd",
  extends_class: "Node",
  content: "extends Node\n\nfunc _ready():\n    pass"
});

await client.callTool("attach_script", {
  node_path: "Root/NewNode",
  script_path: "res://scripts/new_behavior.gd"
});
```

--------------------------------

### Get Tool Mode Function

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/10-types-and-configuration.md

Retrieves the current tool mode from the GODOT_MCP_MODE environment variable.

```typescript
function getToolMode(): ToolMode
```

```typescript
const mode = getToolMode();
console.log(`Running in ${mode} mode`);
```

--------------------------------

### Resources and autoloads

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Tools for managing project resources and autoload configurations.

```text
read_resource / edit_resource / create_resource
add_autoload / remove_autoload / get_autoload
```

--------------------------------

### Copy Addon to Project

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/TESTING.md

Command to copy the plugin addon into a target Godot project directory.

```powershell
xcopy /E /I "C:\dev\godot-mcp\addons\godot_mcp_personal" "C:\dev\my-game\addons\godot_mcp_personal"
```

--------------------------------

### Create New Resource

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Creates a new resource file of a specified type with optional initial properties.

```typescript
create_resource(params: CreateResourceParams) -> { 
  path: string; 
  ok: true 
}
```

```typescript
{
  path: string;
  ok: true;
}
```

--------------------------------

### create_script

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Creates a new GDScript file with optional starter content and configuration.

```APIDOC
## create_script

### Description
Creates a new GDScript file with optional starter content. This is an undoable action.

### Signature
`create_script(params: CreateScriptParams) -> { path: string; ok: true }`

### Parameters
- **script_path** (string) - Required - res:// path for new script
- **content** (string) - Optional - Optional script content
- **extends_class** (string) - Optional - Base class (default: "Node")
- **attach_to_node** (boolean) - Optional - Auto-attach to a node after creation
- **node_path** (string) - Optional - Node path if attach_to_node is true

### Returns
- **path** (string) - The script path
- **ok** (boolean) - Success status

### Throws
- **ALREADY_EXISTS** - Script path already exists
- **INVALID_PARAMS** - script_path is empty or extends_class doesn't exist
- **NOT_FOUND** - node_path doesn't exist (if attach_to_node is true)

### Example
```typescript
const result = await client.callTool("create_script", {
  script_path: "res://scripts/game_manager.gd",
  extends_class: "Node"
});
```
```

--------------------------------

### SCRIPT_ERROR JSON Response

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/03-error-handling.md

Example of the JSON structure returned when a GDScript validation or execution error occurs.

```json
{
  "code": "SCRIPT_ERROR",
  "message": "Syntax error on line 5: expected 'var' but got 'int'",
  "details": {
    "line": 5,
    "column": 1,
    "scriptPath": "res://player.gd"
  }
}
```

--------------------------------

### Trigger INVALID_PARAMS error

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/03-error-handling.md

Example of a tool call that fails validation due to incorrect parameter values.

```typescript
// This will fail with INVALID_PARAMS:
await client.callTool("get_scene_tree", {
  max_depth: -1  // Must be >= 1
});
```

--------------------------------

### Import Main Classes

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/00-README.md

Import the primary GodotClient and error handling classes for the MCP integration.

```typescript
import { GodotClient } from "godot-mcp/src/godotClient.js";
import { GodotMcpError, ErrorCodes } from "godot-mcp/src/errors.js";
```

--------------------------------

### get_project_settings

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Reads project settings from project.godot by keys or prefix.

```APIDOC
## get_project_settings

### Description
Reads project settings from project.godot by keys or prefix.

### Signature
`get_project_settings(params: GetSettingsParams) -> ProjectSettings`

### Parameters
- **keys** (string[]) - Optional - Specific keys to read (e.g., ["application/config/name"])
- **prefix** (string) - Optional - Prefix filter (e.g., "physics/" to get all physics settings)

### Returns
- **ProjectSettings** (Object) - A dictionary mapping setting keys to their values.

### Throws
- **GODOT_NOT_CONNECTED** - Plugin is unreachable
- **TIMEOUT** - Request times out

### Example
```typescript
const settings = await client.callTool("get_project_settings", {
  keys: [
    "application/config/name",
    "application/config/version",
    "physics/2d/default_gravity"
  ]
});
```
```

--------------------------------

### Define get_project_settings return type

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

The expected return structure for project settings.

```typescript
{
  [key: string]: unknown;  // Setting key -> value
  // Example: { "application/config/name": "MyGame" }
}
```

--------------------------------

### get_tool_help

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

Retrieves help metadata for tools, including category and description.

```APIDOC
## get_tool_help

### Description
Retrieves help metadata for tools, including category and description. Can be used to fetch info for a specific tool or all tools.

### Signature
`get_tool_help(tool?: string) -> ToolHelpMetadata | ToolHelpMetadata[]`

### Parameters
- **tool** (string) - Optional - Specific tool name; omit to list all

### Returns
- **ToolHelpMetadata** (object) - Contains name, category, description, signature, and examples.

### Throws
- **NOT_FOUND**: Requested tool does not exist
- **GODOT_NOT_CONNECTED**: Godot plugin is unreachable
- **TIMEOUT**: No response within 30 seconds
```

--------------------------------

### Batch get properties from nodes

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/11-runtime-and-testing-tools-reference.md

Reads multiple properties from various nodes in a single call to optimize performance.

```typescript
const result = await client.callTool("batch_get_properties", {
  requests: [
    { node_path: "Root/Player", properties: ["position", "health"] },
    { node_path: "Root/Enemy", properties: ["position", "alive"] },
    { node_path: "Root/Boss", properties: ["position", "health", "phase"] }
  ]
});

result.results.forEach(r => {
  console.log(`${r.node_path}: ${JSON.stringify(r.properties)}`);
});
```

--------------------------------

### Import Configuration Schemas

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/00-README.md

Import helper functions to retrieve configuration settings like port, tool mode, and timeouts.

```typescript
import {
  getGodotPort,
  getToolMode,
  isDangerousToolsAllowed,
  getRequestTimeoutMs
} from "godot-mcp/src/schemas.js";
```

--------------------------------

### create_resource

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Creates a new resource file.

```APIDOC
## create_resource

### Description
Creates a new resource file.

### Parameters
- **resource_path** (string) - Required - res:// path for new resource
- **resource_type** (string) - Required - Resource class (e.g., "Material")
- **properties** (Record<string, unknown>) - Optional - Initial properties

### Returns
- **path** (string) - Path of the created resource
- **ok** (boolean) - Returns true on success
```

--------------------------------

### Input simulation

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Tools for simulating user input. In-game input requires play mode, while editor-focused tools function within the editor.

```text
simulate_key / simulate_mouse_click / simulate_action / simulate_sequence
get_input_actions / set_input_action
```

--------------------------------

### Get Editor Errors

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Fetches compilation errors and warnings from the GDScript compiler. Use this to monitor project health or display errors in a UI.

```typescript
const result = await client.callTool("get_editor_errors", {});

if (result.count === 0) {
  console.log("No errors");
} else {
  result.errors.forEach(err => {
    console.error(`${err.file}:${err.line}: ${err.message}`);
  });
}
```

--------------------------------

### Define main initialization function

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/02-mcp-server-entry-point.md

The primary entry point function signature for the MCP server.

```typescript
async function main(): Promise<void>
```

--------------------------------

### Zod Schema Definition

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

Example of defining tool parameter validation schemas using Zod to ensure data integrity before transmission to the Godot plugin.

```typescript
export const projectToolSchemas = {
  get_filesystem_tree: z.object({
    path: z.string().optional().default("res://"),
    max_depth: z.number().int().min(1).max(32).optional().default(10),
    include_files: z.boolean().optional().default(true),
  }),
  // ...
};
```

--------------------------------

### Get Output Log

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Retrieves messages from the Godot editor output panel. Supports filtering by message type or text and limiting the number of lines returned.

```typescript
const result = await client.callTool("get_output_log", {
  max_lines: 50
});

// Print recent errors
result.messages
  .filter(m => m.level === "ERROR")
  .forEach(m => console.error(`[${m.timestamp}] ${m.text}`));
```

--------------------------------

### create_scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Creates a new .tscn file and optionally opens it in the editor. This is an undoable action.

```APIDOC
## create_scene

### Description
Creates a new .tscn file and optionally opens it in the editor. This is an undoable action.

### Signature
create_scene(params: CreateSceneParams) -> { path: string; ok: true }

### Parameters
- **scene_path** (string) - Required - res:// path for new scene
- **root_type** (string) - Optional - Root node class (default: "Node2D")
- **root_name** (string) - Optional - Root node name (default: "Root")
- **open** (boolean) - Optional - Open in editor after creating (default: true)

### Returns
- **path** (string) - The path of the created scene
- **ok** (boolean) - Success status

### Throws
- **ALREADY_EXISTS** - Scene path already exists
- **INVALID_PARAMS** - scene_path is invalid or root_type doesn't exist
- **NOT_FOUND** - Parent directory doesn't exist

### Example
const result = await client.callTool("create_scene", {
  scene_path: "res://scenes/level_01.tscn",
  root_type: "Node2D",
  root_name: "Level",
  open: true
});
```

--------------------------------

### Retrieve Project Information

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Fetches core project metadata such as name, version, and directory paths.

```typescript
const info = await client.callTool("get_project_info", {});

console.log(`Project: ${info.project_name} (v${info.project_version})`);
console.log(`Godot: ${info.godot_version}`);
console.log(`Main scene: ${info.main_scene}`);
```

--------------------------------

### Verify server build path

Source: https://github.com/youssof20/godot-mcp/blob/main/README.md

Check that the built index.js file exists at the specified path.

```powershell
Test-Path C:\dev\godot-mcp\dist\index.js   # should be True (use your clone path)
```

--------------------------------

### Execute test suites via PowerShell

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Run these commands in a terminal to verify tool functionality, connectivity, and build integrity. Ensure the Godot editor is active with the plugin enabled before running WebSocket-dependent tests.

```powershell
npm run test:tools       # tool count
npm run test:ping
npm run test:phase3      # … through phase10
npm run test:ci          # build + typecheck
```

--------------------------------

### Configure Cursor MCP settings

Source: https://github.com/youssof20/godot-mcp/blob/main/README.md

JSON configuration for the MCP server in Cursor, requiring an absolute path to the built index.js.

```json
{
  "mcpServers": {
    "godot-mcp": {
      "command": "node",
      "args": ["C:/dev/godot-mcp/dist/index.js"],
      "env": {
        "GODOT_MCP_PORT": "6505",
        "GODOT_MCP_MODE": "full"
      }
    }
  }
}
```

--------------------------------

### Manage scripts

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Tools for script lifecycle management. All paths must be relative to res://.

```text
list_scripts
read_script
create_script / edit_script
attach_script
validate_script
search_in_files
```

--------------------------------

### Retrieve Tool Metadata

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/05-tool-categories-overview.md

Call get_tool_help to retrieve metadata for a specific tool or to list all available tools.

```text
get_tool_help(tool?: string) -> ToolHelpMetadata
```

--------------------------------

### Project Directory Structure

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/INDEX.md

Visual representation of the project file hierarchy and module organization.

```text
godot-mcp/
├── src/
│   ├── index.ts                # Entry point
│   ├── godotClient.ts          # WebSocket client
│   ├── protocol.ts             # Wire protocol types
│   ├── schemas.ts              # Configuration and Zod schemas
│   ├── errors.ts               # Error handling
│   ├── toolRegistry.ts         # Tool registration orchestrator
│   └── tools/
│       ├── server.ts           # Server tools (4 tools)
│       ├── project.ts          # Project tools (7 tools)
│       ├── scene.ts            # Scene tools (7 tools)
│       ├── node.ts             # Node tools (14 tools)
│       ├── script.ts           # Script tools (8 tools)
│       ├── editor.ts           # Editor tools (8 tools)
│       ├── resource.ts         # Resource tools (5 tools)
│       ├── batchRefactor.ts    # Batch refactor (7 tools)
│       ├── runtime.ts          # Runtime tools (17 tools)
│       ├── input.ts            # Input tools (7 tools)
│       ├── testingQa.ts        # Testing tools (12 tools)
│       ├── animation.ts        # Animation (6 tools)
│       ├── animationTree.ts    # Animation tree (7 tools)
│       ├── tilemap.ts          # Tilemap (6 tools)
│       ├── physics.ts          # Physics (6 tools)
│       ├── scene3d.ts          # 3D scenes (8 tools)
│       ├── particles.ts        # Particles (5 tools)
│       ├── navigation.ts       # Navigation (7 tools)
│       ├── audio.ts            # Audio (7 tools)
│       ├── themeUi.ts          # Themes (7 tools)
│       ├── shader.ts           # Shaders (6 tools)
│       ├── profiling.ts        # Profiling (2 tools)
│       ├── export.ts           # Export (3 tools)
│       ├── analysis.ts         # Analysis (5 tools)
│       ├── constants.ts        # Tool lists and modes
│       ├── helpers.ts          # registerGodotTool helper
│       └── ...
├── package.json
├── tsconfig.json
├── dist/
│   └── index.js                # Compiled entry point
└── addons/
    └── godot_mcp_personal/     # Godot plugin
```

--------------------------------

### list_available_tools

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

Returns a list of all tools that are implemented end-to-end and currently available.

```APIDOC
## list_available_tools

### Description
Returns a list of all tools that are implemented end-to-end and currently available (not planned or disabled).

### Signature
`list_available_tools() -> { tools: string[], typescript_registered: string[], count: number }`

### Parameters
None

### Returns
- **tools** (string[]) - List of available tool names
- **typescript_registered** (string[]) - List of tools registered in TypeScript
- **count** (number) - Total count of available tools

### Throws
- **GODOT_NOT_CONNECTED**: Godot plugin is unreachable
- **TIMEOUT**: No response within 30 seconds
```

--------------------------------

### Configure Cursor MCP

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/TESTING.md

JSON configuration for the Cursor MCP settings to connect to the Godot server.

```json
{
  "mcpServers": {
    "godot-mcp": {
      "command": "node",
      "args": ["C:/dev/godot-mcp/dist/index.js"],
      "env": {
        "GODOT_MCP_PORT": "6505"
      }
    }
  }
}
```

--------------------------------

### Run Smoke Tests

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/00-README.md

Execute various npm scripts to verify tool availability, editor connectivity, and project integration.

```bash
npm run test:tools           # List all 172 tools
npm run test:ping           # Ping the Godot editor
npm run test:project        # Get project info
npm run test:phase11        # Full integration test
```

--------------------------------

### set_project_setting

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Sets a project.godot setting. This is an undoable action and automatically saves the project.

```APIDOC
## set_project_setting

### Description
Sets a project.godot setting. This is an undoable action and automatically saves the project.

### Signature
`set_project_setting(params: SetSettingParams) -> { ok: true; key: string; value: unknown }`

### Parameters
- **key** (string) - Required - Setting key (e.g., "physics/2d/default_gravity")
- **value** (unknown) - Required - New value (type depends on setting)

### Returns
`{ ok: true; key: string; value: unknown }`

### Throws
- **INVALID_PARAMS**: key is empty or value type is wrong
- **GODOT_NOT_CONNECTED**: Plugin is unreachable

### Example
```typescript
const result = await client.callTool("set_project_setting", {
  key: "physics/2d/default_gravity",
  value: 980
});
```
```

--------------------------------

### List Available Tools Return Structure

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

The expected return structure for the list_available_tools function.

```typescript
{
  tools: [
    "godot_ping",
    "get_connection_status",
    "list_available_tools",
    // ... all 172 tool names
  ];
  typescript_registered: [
    // Same list from IMPLEMENTED_TOOLS constant
  ];
  count: number;  // Total count
}
```

--------------------------------

### Create a new scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Generates a new .tscn file with a specified root node type and name, optionally opening it in the editor.

```typescript
const result = await client.callTool("create_scene", {
  scene_path: "res://scenes/level_01.tscn",
  root_type: "Node2D",
  root_name: "Level",
  open: true
});

console.log(`Created scene at ${result.path}`);
```

--------------------------------

### List Available Tools Signature

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/06-server-tools-reference.md

The signature for the list_available_tools function.

```typescript
list_available_tools() -> {
  tools: string[];
  typescript_registered: string[];
  count: number;
}
```

--------------------------------

### Define add_resource signature and return type

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/08-node-tools-reference.md

Defines the structure for the add_resource tool parameters and its return object.

```typescript
add_resource(params: AddResourceParams) -> { 
  node_path: string; 
  property: string; 
  resource_path: string; 
  ok: true 
}
```

```typescript
{
  node_path: string;
  property: string;
  resource_path: string;
  ok: true;
}
```

--------------------------------

### navigate_to

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/11-runtime-and-testing-tools-reference.md

Commands a character node to navigate to a position.

```APIDOC
## navigate_to

### Description
Commands a character node to navigate to a position (if it has navigation/movement code).

### Parameters
- **node_path** (string) - Required - Character node.
- **position** (object) - Required - Target position {x: number, y: number}.

### Returns
- **ok** (boolean) - Success status.
```

--------------------------------

### Search for function definitions and class references

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Demonstrates how to use the search_in_files tool to perform both filtered searches with extensions and case-sensitive searches within specific directories.

```typescript
// Search for function definition
const result = await client.callTool("search_in_files", {
  query: "func _ready",
  extensions: [".gd"],
  max_results: 50
});

console.log(`Found ${result.count} matches`);
result.results.forEach(r => {
  console.log(`${r.file_path}:${r.line_number}: ${r.line_content}`);
});

// Case-sensitive search
const classRefs = await client.callTool("search_in_files", {
  query: "Player",
  case_sensitive: true,
  path: "res://scripts"
});

classRefs.results.forEach(r => console.log(r.file_path));
```

--------------------------------

### Find Resource References

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Locates all instances where a specific resource is used within the project.

```typescript
find_resource_references(params: FindRefsParams) -> { 
  references: Reference[] 
}
```

```typescript
{
  references: {
    path: string;         // Where it's used (scene, script, resource)
    property?: string;    // Property name if in a scene
    type: string;         // "scene" | "script" | "resource"
  }[];
}
```

--------------------------------

### uid_to_project_path

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Converts a resource UID to its res:// project path.

```APIDOC
## uid_to_project_path

### Description
Converts a resource UID to its res:// project path.

### Signature
`uid_to_project_path(params: UidToPathParams) -> { path: string }`

### Parameters
- **uid** (string) - Required - UID string (with or without "uid://" prefix)

### Returns
`{ path: string }`

### Throws
- **NOT_FOUND**: UID does not exist in project
- **INVALID_PARAMS**: uid is empty

### Example
```typescript
const result = await client.callTool("uid_to_project_path", {
  uid: "uid://abcd1234efgh5678"
});
```
```

--------------------------------

### registerGodotTool()

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/05-tool-categories-overview.md

Registers a single tool with the MCP server if it is included in the enabled set.

```APIDOC
## registerGodotTool()

### Description
Registers a single tool with the MCP server. The function checks if the tool name is in the enabled set before registering it with the server and setting up the handler to call the Godot client.

### Signature
function registerGodotTool(
  server: McpServer,
  client: GodotClient,
  enabled: Set<string>,
  name: string,
  description: string,
  shape: z.ZodRawShape
): void

### Parameters
- **server** (McpServer) - The MCP server instance.
- **client** (GodotClient) - The Godot client instance.
- **enabled** (Set<string>) - A set of enabled tool names.
- **name** (string) - The name of the tool.
- **description** (string) - A description of the tool.
- **shape** (z.ZodRawShape) - The Zod schema shape for the tool parameters.

### Example
registerGodotTool(
  server,
  client,
  enabled,
  "get_project_info",
  "Get Godot project name, paths, version, and main scene.",
  projectToolSchemas.get_project_info.shape
);
```

--------------------------------

### Implement callTool Request Logic

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/04-wire-protocol.md

Pseudo-code demonstrating the request lifecycle, including connection verification, UUID generation, and promise-based timeout handling.

```typescript
async callTool(method: string, params: Record<string, unknown>) {
  await this.ensureConnected();
  
  const id = randomUUID();
  const request = { id, method, params };
  
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      this.pending.delete(id);
      reject(new GodotMcpError(TIMEOUT, ...));
    }, this.timeoutMs);
    
    this.pending.set(id, { resolve, reject, timer });
    
    try {
      this.ws.send(JSON.stringify(request));
    } catch (error) {
      this.pending.delete(id);
      clearTimeout(timer);
      reject(error);
    }
  });
}
```

--------------------------------

### Throwing a GodotMcpError

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/03-error-handling.md

Demonstrates how to instantiate and throw a GodotMcpError with specific error codes and contextual metadata.

```typescript
throw new GodotMcpError(
  ErrorCodes.NOT_FOUND,
  "Script 'player.gd' not found in project",
  {
    suggestion: "Check the script path matches a file in the project",
    details: { attempted_path: "res://player.gd" }
  }
);
```

--------------------------------

### get_project_info

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Retrieves fundamental Godot project metadata including name, paths, version, and main scene.

```APIDOC
## get_project_info

### Description
Retrieves fundamental Godot project metadata: name, paths, version, and main scene.

### Signature
`get_project_info() -> ProjectInfo`

### Returns
- **project_name** (string) - Name from project.godot
- **project_version** (string) - Version field
- **godot_version** (string) - e.g., "4.4.0"
- **main_scene** (string) - res:// path to main scene
- **data_dir** (string) - Project data folder
- **config_dir** (string) - Config folder
- **res_dir** (string) - res:// root directory
- **user_dir** (string) - user:// root directory
- **is_debug** (boolean) - Debug vs. release

### Throws
- **GODOT_NOT_CONNECTED**: Godot plugin is unreachable
- **TIMEOUT**: No response within 30 seconds

### Example
```typescript
const info = await client.callTool("get_project_info", {});
```
```

--------------------------------

### Define get_project_settings signature

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

The function signature for retrieving project settings.

```typescript
get_project_settings(params: GetSettingsParams) -> ProjectSettings
```

--------------------------------

### Screenshots and testing

Source: https://github.com/youssof20/godot-mcp/blob/main/docs/DOCUMENTATION.md

Tools for capturing visual state and running automated tests. Captures are saved to user://mcp_captures/.

```text
get_editor_screenshot / get_game_screenshot
compare_screenshots
run_test_scenario / assert_node_state / get_test_report
```

--------------------------------

### Define get_scene_dependencies signature

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Defines the input parameters for the get_scene_dependencies tool.

```typescript
get_scene_dependencies(params: DependencyParams) -> { 
  dependencies: Dependency[] 
}
```

--------------------------------

### open_scene

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Opens a specified scene file in the Godot editor for editing.

```APIDOC
## open_scene

### Description
Opens a scene in the Godot editor for editing.

### Signature
`open_scene(params: OpenSceneParams) -> { path: string; ok: true }`

### Parameters
- **scene_path** (string) - Required - res:// path to scene file

### Returns
- **path** (string) - The path of the opened scene
- **ok** (boolean) - Success status

### Throws
- **NOT_FOUND**: Scene file not found
- **SCENE_ERROR**: Scene file is corrupted

### Example
```typescript
await client.callTool("open_scene", {
  scene_path: "res://main.tscn"
});
```
```

--------------------------------

### Open a scene in the Godot editor

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/07-project-and-scene-tools-reference.md

Opens a specified scene file in the editor. Requires a valid res:// path.

```typescript
open_scene(params: OpenSceneParams) -> { path: string; ok: true }
```

```typescript
{
  path: string;
  ok: true;
}
```

```typescript
await client.callTool("open_scene", {
  scene_path: "res://main.tscn"
});

console.log("Scene opened in editor");
```

--------------------------------

### Create a new script file

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/09-script-tools-reference.md

Generates a new GDScript file with options for base class extension, initial content, and node attachment.

```typescript
// Create empty script extending Node
const result = await client.callTool("create_script", {
  script_path: "res://scripts/game_manager.gd",
  extends_class: "Node"
});

console.log(`Created ${result.path}`);

// Create with custom content
await client.callTool("create_script", {
  script_path: "res://scripts/player.gd",
  content: `extends Node2D

var speed = 100

func _ready():
    pass

func _process(delta):
    pass
`,
  attach_to_node: true,
  node_path: "Root/Player"
});

// Create extending a custom class
await client.callTool("create_script", {
  script_path: "res://scripts/enemy.gd",
  extends_class: "CharacterBody2D"
});
```

--------------------------------

### get_scene_dependencies

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/12-editor-and-specialized-tools-reference.md

Returns all scenes and resources that a specific scene depends on.

```APIDOC
## get_scene_dependencies

### Description
Returns all scenes and resources a scene depends on.

### Parameters
- **scene_path** (string) - Required - Scene to analyze

### Returns
- **dependencies** (array) - List of objects containing path, type (scene/script/resource), and optional is_circular flag
```

--------------------------------

### Define set_anchor_preset signature and return type

Source: https://github.com/youssof20/godot-mcp/blob/main/_autodocs/08-node-tools-reference.md

Defines the structure for the set_anchor_preset tool parameters and its return object.

```typescript
set_anchor_preset(params: SetAnchorParams) -> { 
  node_path: string; 
  preset: string | number; 
  ok: true 
}
```

```typescript
{
  node_path: string;
  preset: string | number;
  ok: true;
}
```
Tokens:
Raw