godot-mcp-runtime 2.2.3 → 3.0.0

package/dist/tools/node-tools.js

@@ -1,11 +1,13 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { normalizeParameters, convertCamelToSnakeCase, validatePath, createErrorResponse, extractGdError, validateSceneArgs, } from '../utils/godot-runner.js';
+import { normalizeParameters, convertCamelToSnakeCase, validatePath, createErrorResponse, validateSceneArgs, } from '../utils/godot-runner.js';
+import { executeSceneOp } from '../utils/handler-helpers.js';
 // --- Tool definitions ---
 export const nodeToolDefinitions = [
     {
-        name: 'delete_node',
-        description: 'Remove a node from a Godot scene file. Saves automatically.',
+        name: 'delete_nodes',
+        description: 'Remove one or more nodes (and their descendants) from a scene file. Always-array: pass a single-element nodePaths array for one-off deletes. Saves once at the end. Cannot delete the scene root — that entry returns an error and the rest still process. Returns { results: [{ nodePath, success?, error? }] }.',
+        annotations: { destructiveHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -14,35 +16,19 @@ export const nodeToolDefinitions = [
                     type: 'string',
                     description: 'Scene file path relative to the project (e.g. "scenes/main.tscn")',
                 },
-                nodePath: {
-                    type: 'string',
-                    description: 'Node path from scene root (e.g. "root/Player/Sprite2D")',
-                },
-            },
-            required: ['projectPath', 'scenePath', 'nodePath'],
-        },
-    },
-    {
-        name: 'set_node_property',
-        description: 'Set a property on a node in a Godot scene file. Saves automatically. Primitives (string, number, boolean, array, object) are passed as-is. Vector2 ({"x","y"}), Vector3 ({"x","y","z"}), and Color ({"r","g","b","a"}) are automatically converted. Use run_script for other complex GDScript types.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
-                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
-                nodePath: { type: 'string', description: 'Node path from scene root (e.g. "root/Player")' },
-                property: {
-                    type: 'string',
-                    description: 'GDScript property name in snake_case (e.g. "position", "modulate", "collision_layer"). Use get_node_properties to discover valid names.',
+                nodePaths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Node paths from scene root to delete (e.g. ["root/Player/Sprite2D"])',
                 },
-                value: { description: 'New property value' },
             },
-            required: ['projectPath', 'scenePath', 'nodePath', 'property', 'value'],
+            required: ['projectPath', 'scenePath', 'nodePaths'],
         },
     },
     {
-        name: 'batch_set_node_properties',
-        description: 'Set multiple node properties in a single Godot process. Saves automatically. Returns { results: [{ nodePath, property, success?, error? }] }.',
+        name: 'set_node_properties',
+        description: 'Set one or more node properties on a scene in a single Godot process. Always-array: pass a single-element updates array for one-off edits. Vector2 ({x,y}), Vector3 ({x,y,z}), and Color ({r,g,b,a}) auto-convert; primitives pass through. For other complex GDScript types (Resource, NodePath, etc.), use run_script. abortOnError stops on first failure (default false continues). Saves once at the end. Returns { results: [{ nodePath, property, success?, error? }] }.',
+        annotations: { idempotentHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -54,8 +40,14 @@ export const nodeToolDefinitions = [
                     items: {
                         type: 'object',
                         properties: {
-                            nodePath: { type: 'string', description: 'Node path from scene root' },
-                            property: { type: 'string', description: 'GDScript property name in snake_case' },
+                            nodePath: {
+                                type: 'string',
+                                description: 'Node path from scene root (e.g. "root/Player")',
+                            },
+                            property: {
+                                type: 'string',
+                                description: 'GDScript property name in snake_case (e.g. "position", "modulate", "collision_layer")',
+                            },
                             value: { description: 'New property value' },
                         },
                         required: ['nodePath', 'property', 'value'],
@@ -71,24 +63,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'get_node_properties',
-        description: "Read a node's current property values from a Godot scene file.",
-        inputSchema: {
-            type: 'object',
-            properties: {
-                projectPath: { type: 'string', description: 'Path to the Godot project directory' },
-                scenePath: { type: 'string', description: 'Scene file path relative to the project' },
-                nodePath: { type: 'string', description: 'Node path from scene root (e.g. "root/Player")' },
-                changedOnly: {
-                    type: 'boolean',
-                    description: 'Only return properties whose values differ from their class defaults (default: false)',
-                },
-            },
-            required: ['projectPath', 'scenePath', 'nodePath'],
-        },
-    },
-    {
-        name: 'batch_get_node_properties',
-        description: 'Get properties from multiple nodes in a single Godot process. Returns { results: [{ nodePath, nodeType, properties?, error? }] }.',
+        description: "Read one or more nodes' current property values from a scene file in a single Godot process. Always-array: pass a single-element nodes array for one-off reads. Per-node changedOnly:true filters out properties matching class defaults (useful for compact diffs). Returns { results: [{ nodePath, nodeType, properties?, error? }] }; failed reads include error and omit properties.",
+        annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -100,7 +76,10 @@ export const nodeToolDefinitions = [
                     items: {
                         type: 'object',
                         properties: {
-                            nodePath: { type: 'string', description: 'Node path from scene root' },
+                            nodePath: {
+                                type: 'string',
+                                description: 'Node path from scene root (e.g. "root/Player")',
+                            },
                             changedOnly: {
                                 type: 'boolean',
                                 description: 'Only return properties differing from defaults (default: false)',
@@ -115,7 +94,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'attach_script',
-        description: 'Attach a GDScript file to a node in a Godot scene. Saves automatically.',
+        description: 'Attach an existing GDScript file to a node in a scene. Use after writing the script with the standard file tools and validating it via the validate tool. Replaces any previously attached script. Saves automatically. Errors if scriptPath does not exist or nodePath is not found. Returns { success, nodePath, scriptPath }.',
+        annotations: { idempotentHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -132,7 +112,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'get_scene_tree',
-        description: 'Get the scene hierarchy as a tree structure. Use maxDepth: 1 for a shallow listing of direct children only.',
+        description: 'Get the scene hierarchy as a nested tree of { name, type, path, script, children }. Use maxDepth:1 for a shallow listing of direct children only; default -1 returns the full tree. parentPath scopes the result to a subtree. Returns the nested tree as JSON text. Errors if scene does not exist or parentPath is not found.',
+        annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -152,7 +133,7 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'duplicate_node',
-        description: 'Duplicate a node and its children in a Godot scene. Saves automatically.',
+        description: 'Duplicate a node and its descendants in a Godot scene. Use to clone a configured subtree without re-creating it node-by-node via add_node. newName defaults to the original name + "2"; targetParentPath defaults to the original parent. Saves automatically. Errors if nodePath does not exist or targetParentPath cannot accept children. Returns { success, originalPath, newPath }.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -173,7 +154,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'get_node_signals',
-        description: 'List all signals defined on a node and their current connections. Returns { nodePath, nodeType, signals: [{ name, connections: [{ signal, target, method }] }] }. Note: the target field uses Godot absolute path format (e.g. /root/Scene/Node) — convert to scene-root-relative (e.g. root/Node) before passing to connect_signal or disconnect_signal.',
+        description: 'List all signals defined on a node and their current connections. Use before connect_signal/disconnect_signal to verify signal/method names. Returns { nodePath, nodeType, signals: [{ name, connections: [{ signal, target, method }] }] }. The target field uses Godot absolute path format (/root/Scene/Node) — convert to scene-root-relative (root/Node) before passing to connect/disconnect_signal. Errors if node not found.',
+        annotations: { readOnlyHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -186,7 +168,7 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'connect_signal',
-        description: 'Connect a signal from one node to a method on another node. Saves automatically. Errors if the signal does not exist on the source node or the method does not exist on the target node.',
+        description: 'Connect a signal on a source node to a method on a target node, persisting the connection in the .tscn. Use after get_node_signals to confirm the signal name on the source and the method name on the target. Connecting the same signal+method pair twice creates a duplicate connection — call get_node_signals first if uncertain. Saves automatically. Returns a plain-text confirmation naming the source, signal, target, and method. Errors if the signal does not exist on the source node or the method does not exist on the target node.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -211,7 +193,8 @@ export const nodeToolDefinitions = [
     },
     {
         name: 'disconnect_signal',
-        description: 'Disconnect a signal connection between two nodes. Saves automatically. Errors if the connection does not exist — use get_node_signals first to verify.',
+        description: 'Remove an existing signal connection between two nodes, persisting the change in the .tscn. Use get_node_signals first to confirm the connection exists; recovery requires reconnecting via connect_signal. Saves automatically. Returns a plain-text confirmation naming the disconnected signal and target. Errors if the connection does not exist.',
+        annotations: { destructiveHint: true },
         inputSchema: {
             type: 'object',
             properties: {
@@ -227,71 +210,29 @@ export const nodeToolDefinitions = [
     },
 ];
 // --- Handlers ---
-export async function handleDeleteNode(runner, args) {
-    args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
-    if ('isError' in v)
-        return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
-        ]);
-    }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        const { stdout, stderr } = await runner.executeOperation('delete_node', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to delete node: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to delete node: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
-}
-export async function handleSetNodeProperty(runner, args) {
+export async function handleDeleteNodes(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
-        ]);
-    }
-    if (!args.property || args.value === undefined) {
-        return createErrorResponse('property and value are required', [
-            'Provide both property name and value',
+    if (!args.nodePaths || !Array.isArray(args.nodePaths) || args.nodePaths.length === 0) {
+        return createErrorResponse('nodePaths array is required', [
+            'Provide a non-empty array of node paths (e.g. ["root/Player"])',
         ]);
     }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            property: args.property,
-            value: args.value,
-        };
-        const { stdout, stderr } = await runner.executeOperation('set_node_property', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to update property: ${extractGdError(stderr)}`, [
-                'Check if the property name is valid for this node type',
+    for (const p of args.nodePaths) {
+        if (typeof p !== 'string' || !validatePath(p)) {
+            return createErrorResponse('Invalid nodePath in nodePaths', [
+                'Provide valid paths without ".." (e.g. "root/Player")',
             ]);
         }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to set node property: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
     }
+    const params = { scenePath: args.scenePath, nodePaths: args.nodePaths };
+    return executeSceneOp(runner, 'delete_nodes', params, v.projectPath, 'Failed to delete nodes', [
+        'Check if the node paths are correct',
+    ]);
 }
-export async function handleBatchSetNodeProperties(runner, args) {
+export async function handleSetNodeProperties(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
@@ -301,58 +242,15 @@ export async function handleBatchSetNodeProperties(runner, args) {
             'Provide an array of { nodePath, property, value }',
         ]);
     }
-    try {
-        const snakeUpdates = args.updates.map((u) => convertCamelToSnakeCase(u));
-        const params = {
-            scenePath: args.scenePath,
-            updates: snakeUpdates,
-            abortOnError: args.abortOnError ?? false,
-        };
-        const { stdout, stderr } = await runner.executeOperation('batch_set_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Batch update failed: ${extractGdError(stderr)}`, [
-                'Check node paths and property names',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Batch set properties failed: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const snakeUpdates = args.updates.map((u) => convertCamelToSnakeCase(u));
+    const params = {
+        scenePath: args.scenePath,
+        updates: snakeUpdates,
+        abortOnError: args.abortOnError ?? false,
+    };
+    return executeSceneOp(runner, 'set_node_properties', params, v.projectPath, 'Failed to set node properties', ['Check node paths and property names']);
 }
 export async function handleGetNodeProperties(runner, args) {
-    args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
-    if ('isError' in v)
-        return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', [
-            'Provide the node path (e.g. "root/Player")',
-        ]);
-    }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        if (args.changedOnly)
-            params.changedOnly = args.changedOnly;
-        const { stdout, stderr } = await runner.executeOperation('get_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get properties: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get node properties: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
-}
-export async function handleBatchGetNodeProperties(runner, args) {
     args = normalizeParameters(args);
     const v = validateSceneArgs(args);
     if ('isError' in v)
@@ -362,23 +260,9 @@ export async function handleBatchGetNodeProperties(runner, args) {
             'Provide an array of { nodePath, changedOnly? }',
         ]);
     }
-    try {
-        const snakeNodes = args.nodes.map((n) => convertCamelToSnakeCase(n));
-        const params = { scenePath: args.scenePath, nodes: snakeNodes };
-        const { stdout, stderr } = await runner.executeOperation('batch_get_node_properties', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Batch get_properties failed: ${extractGdError(stderr)}`, [
-                'Check node paths',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Batch get properties failed: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const snakeNodes = args.nodes.map((n) => convertCamelToSnakeCase(n));
+    const params = { scenePath: args.scenePath, nodes: snakeNodes };
+    return executeSceneOp(runner, 'get_node_properties', params, v.projectPath, 'Failed to get node properties', ['Check node paths']);
 }
 export async function handleAttachScript(runner, args) {
     args = normalizeParameters(args);
@@ -401,26 +285,14 @@ export async function handleAttachScript(runner, args) {
             'Create the script file first',
         ]);
     }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            scriptPath: args.scriptPath,
-        };
-        const { stdout, stderr } = await runner.executeOperation('attach_script', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to attach script: ${extractGdError(stderr)}`, [
-                'Ensure the script is valid for this node type',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to attach script: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = {
+        scenePath: args.scenePath,
+        nodePath: args.nodePath,
+        scriptPath: args.scriptPath,
+    };
+    return executeSceneOp(runner, 'attach_script', params, v.projectPath, 'Failed to attach script', [
+        'Ensure the script is valid for this node type',
+    ]);
 }
 export async function handleGetSceneTree(runner, args) {
     args = normalizeParameters(args);
@@ -430,26 +302,12 @@ export async function handleGetSceneTree(runner, args) {
     if (args.parentPath && !validatePath(args.parentPath)) {
         return createErrorResponse('Invalid parentPath', ['Provide a valid path without ".."']);
     }
-    try {
-        const params = { scenePath: args.scenePath };
-        if (args.parentPath)
-            params.parentPath = args.parentPath;
-        if (typeof args.maxDepth === 'number')
-            params.maxDepth = args.maxDepth;
-        const { stdout, stderr } = await runner.executeOperation('get_scene_tree', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get scene tree: ${extractGdError(stderr)}`, [
-                'Ensure the scene is valid',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get scene tree: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = { scenePath: args.scenePath };
+    if (args.parentPath)
+        params.parentPath = args.parentPath;
+    if (typeof args.maxDepth === 'number')
+        params.maxDepth = args.maxDepth;
+    return executeSceneOp(runner, 'get_scene_tree', params, v.projectPath, 'Failed to get scene tree', ['Ensure the scene is valid']);
 }
 export async function handleDuplicateNode(runner, args) {
     args = normalizeParameters(args);
@@ -464,26 +322,12 @@ export async function handleDuplicateNode(runner, args) {
     if (args.targetParentPath && !validatePath(args.targetParentPath)) {
         return createErrorResponse('Invalid targetParentPath', ['Provide a valid path without ".."']);
     }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        if (args.newName)
-            params.newName = args.newName;
-        if (args.targetParentPath)
-            params.targetParentPath = args.targetParentPath;
-        const { stdout, stderr } = await runner.executeOperation('duplicate_node', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to duplicate node: ${extractGdError(stderr)}`, [
-                'Check if the node path and target parent path are correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to duplicate node: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = { scenePath: args.scenePath, nodePath: args.nodePath };
+    if (args.newName)
+        params.newName = args.newName;
+    if (args.targetParentPath)
+        params.targetParentPath = args.targetParentPath;
+    return executeSceneOp(runner, 'duplicate_node', params, v.projectPath, 'Failed to duplicate node', ['Check if the node path and target parent path are correct']);
 }
 export async function handleGetNodeSignals(runner, args) {
     args = normalizeParameters(args);
@@ -495,25 +339,10 @@ export async function handleGetNodeSignals(runner, args) {
             'Provide the node path (e.g. "root/Button")',
         ]);
     }
-    try {
-        const params = { scenePath: args.scenePath, nodePath: args.nodePath };
-        const { stdout, stderr } = await runner.executeOperation('get_node_signals', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to get signals: ${extractGdError(stderr)}`, [
-                'Check if the node path is correct',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to get node signals: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = { scenePath: args.scenePath, nodePath: args.nodePath };
+    return executeSceneOp(runner, 'get_node_signals', params, v.projectPath, 'Failed to get node signals', ['Check if the node path is correct']);
 }
-export async function handleConnectSignal(runner, args) {
-    args = normalizeParameters(args);
+function validateSignalArgs(args) {
     const v = validateSceneArgs(args);
     if ('isError' in v)
         return v;
@@ -528,66 +357,41 @@ export async function handleConnectSignal(runner, args) {
     if (!validatePath(args.targetNodePath)) {
         return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
     }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            signal: args.signal,
-            targetNodePath: args.targetNodePath,
-            method: args.method,
-        };
-        const { stdout, stderr } = await runner.executeOperation('connect_signal', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to connect signal: ${extractGdError(stderr)}`, [
-                'Ensure the signal exists on the source node and the method exists on the target node',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to connect signal: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    return {
+        projectPath: v.projectPath,
+        scenePath: v.scenePath,
+        nodePath: args.nodePath,
+        signal: args.signal,
+        targetNodePath: args.targetNodePath,
+        method: args.method,
+    };
+}
+export async function handleConnectSignal(runner, args) {
+    args = normalizeParameters(args);
+    const v = validateSignalArgs(args);
+    if ('isError' in v)
+        return v;
+    const params = {
+        scenePath: v.scenePath,
+        nodePath: v.nodePath,
+        signal: v.signal,
+        targetNodePath: v.targetNodePath,
+        method: v.method,
+    };
+    return executeSceneOp(runner, 'connect_signal', params, v.projectPath, 'Failed to connect signal', ['Ensure the signal exists on the source node and the method exists on the target node']);
 }
 export async function handleDisconnectSignal(runner, args) {
     args = normalizeParameters(args);
-    const v = validateSceneArgs(args);
+    const v = validateSignalArgs(args);
     if ('isError' in v)
         return v;
-    if (!args.nodePath || !validatePath(args.nodePath)) {
-        return createErrorResponse('Valid nodePath is required', ['Provide the source node path']);
-    }
-    if (!args.signal || !args.targetNodePath || !args.method) {
-        return createErrorResponse('signal, targetNodePath, and method are required', [
-            'Provide all three parameters',
-        ]);
-    }
-    if (!validatePath(args.targetNodePath)) {
-        return createErrorResponse('Invalid targetNodePath', ['Provide a valid path without ".."']);
-    }
-    try {
-        const params = {
-            scenePath: args.scenePath,
-            nodePath: args.nodePath,
-            signal: args.signal,
-            targetNodePath: args.targetNodePath,
-            method: args.method,
-        };
-        const { stdout, stderr } = await runner.executeOperation('disconnect_signal', params, v.projectPath);
-        if (!stdout.trim()) {
-            return createErrorResponse(`Failed to disconnect signal: ${extractGdError(stderr)}`, [
-                'Ensure the signal connection exists before trying to disconnect it',
-            ]);
-        }
-        return { content: [{ type: 'text', text: stdout }] };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return createErrorResponse(`Failed to disconnect signal: ${errorMessage}`, [
-            'Ensure Godot is installed correctly',
-        ]);
-    }
+    const params = {
+        scenePath: v.scenePath,
+        nodePath: v.nodePath,
+        signal: v.signal,
+        targetNodePath: v.targetNodePath,
+        method: v.method,
+    };
+    return executeSceneOp(runner, 'disconnect_signal', params, v.projectPath, 'Failed to disconnect signal', ['Ensure the signal connection exists before trying to disconnect it']);
 }
 //# sourceMappingURL=node-tools.js.map