@satelliteoflove/godot-mcp 0.1.5 → 0.1.6

package/dist/tools/animation.js

@@ -1,382 +1,334 @@
+/**
+ * Animation Tools - consolidated tools for animation operations
+ *
+ * SCHEMA PATTERN FOR CONSOLIDATED TOOLS:
+ *
+ * Claude Code requires tool schemas to have `type: "object"` at the root.
+ * Do NOT use z.discriminatedUnion() - it generates `anyOf` at the root level,
+ * which causes Claude Code to reject the entire MCP tool list.
+ *
+ * Instead, use a flat object schema with .refine() for runtime validation:
+ *
+ *   const Schema = z.object({
+ *     action: z.enum(['foo', 'bar']).describe('Action: foo, bar'),
+ *     param1: z.string().optional().describe('Description (foo only)'),
+ *     param2: z.number().optional().describe('Description (bar only)'),
+ *   }).refine((data) => {
+ *     switch (data.action) {
+ *       case 'foo': return !!data.param1;
+ *       case 'bar': return data.param2 !== undefined;
+ *     }
+ *   }, { message: 'Missing required fields for action' });
+ *
+ * The .refine() runs at runtime only - it doesn't affect the JSON schema output.
+ * Use field descriptions to indicate which action each field applies to.
+ */
 import { z } from 'zod';
 import { defineTool } from '../core/define-tool.js';
-export const listAnimationPlayers = defineTool({
-    name: 'list_animation_players',
-    description: 'Find all AnimationPlayer nodes in the scene',
-    schema: z.object({
-        root_path: z
-            .string()
-            .optional()
-            .describe('Starting node path, defaults to scene root'),
-    }),
-    async execute({ root_path }, { godot }) {
-        const result = await godot.sendCommand('list_animation_players', { root_path });
-        if (result.animation_players.length === 0) {
-            return 'No AnimationPlayer nodes found in scene';
+const AnimationQuerySchema = z
+    .object({
+    action: z
+        .enum(['list_players', 'get_info', 'get_details', 'get_keyframes'])
+        .describe('Action: list_players, get_info, get_details, get_keyframes'),
+    root_path: z.string().optional().describe('Starting node path (list_players only)'),
+    node_path: z.string().optional().describe('Path to AnimationPlayer (required except list_players)'),
+    animation_name: z.string().optional().describe('Animation name (get_details, get_keyframes)'),
+    track_index: z.number().optional().describe('Track index (get_keyframes only)'),
+})
+    .refine((data) => {
+    switch (data.action) {
+        case 'list_players':
+            return true;
+        case 'get_info':
+            return !!data.node_path;
+        case 'get_details':
+            return !!data.node_path && !!data.animation_name;
+        case 'get_keyframes':
+            return !!data.node_path && !!data.animation_name && data.track_index !== undefined;
+    }
+}, { message: 'Missing required fields for action' });
+export const animationQuery = defineTool({
+    name: 'animation_query',
+    description: 'Query animation data. Actions: list_players (find AnimationPlayers), get_info (player state), get_details (animation tracks/length), get_keyframes (track keyframes)',
+    schema: AnimationQuerySchema,
+    async execute(args, { godot }) {
+        switch (args.action) {
+            case 'list_players': {
+                const result = await godot.sendCommand('list_animation_players', { root_path: args.root_path });
+                if (result.animation_players.length === 0) {
+                    return 'No AnimationPlayer nodes found in scene';
+                }
+                return `Found ${result.animation_players.length} AnimationPlayer(s):\n${result.animation_players.map((p) => `  - ${p.path}`).join('\n')}`;
+            }
+            case 'get_info': {
+                const result = await godot.sendCommand('get_animation_player_info', { node_path: args.node_path });
+                return JSON.stringify(result, null, 2);
+            }
+            case 'get_details': {
+                const result = await godot.sendCommand('get_animation_details', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                });
+                return JSON.stringify(result, null, 2);
+            }
+            case 'get_keyframes': {
+                const result = await godot.sendCommand('get_track_keyframes', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_index: args.track_index,
+                });
+                return JSON.stringify(result, null, 2);
+            }
         }
-        return `Found ${result.animation_players.length} AnimationPlayer(s):\n${result.animation_players.map((p) => `  - ${p.path}`).join('\n')}`;
     },
 });
-export const getAnimationPlayerInfo = defineTool({
-    name: 'get_animation_player_info',
-    description: 'Get AnimationPlayer state and available animations',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer node'),
-    }),
-    async execute({ node_path }, { godot }) {
-        const result = await godot.sendCommand('get_animation_player_info', { node_path });
-        return JSON.stringify(result, null, 2);
-    },
-});
-export const getAnimationDetails = defineTool({
-    name: 'get_animation_details',
-    description: 'Get detailed information about a specific animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z
-            .string()
-            .describe('Name of animation (format: "library/anim" or just "anim")'),
-    }),
-    async execute({ node_path, animation_name }, { godot }) {
-        const result = await godot.sendCommand('get_animation_details', { node_path, animation_name });
-        return JSON.stringify(result, null, 2);
-    },
-});
-export const getTrackKeyframes = defineTool({
-    name: 'get_track_keyframes',
-    description: 'Get all keyframes for a specific track',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation name'),
-        track_index: z.number().describe('Track index'),
-    }),
-    async execute({ node_path, animation_name, track_index }, { godot }) {
-        const result = await godot.sendCommand('get_track_keyframes', { node_path, animation_name, track_index });
-        return JSON.stringify(result, null, 2);
-    },
-});
-export const playAnimation = defineTool({
-    name: 'play_animation',
-    description: 'Play an animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to play'),
-        custom_blend: z
-            .number()
-            .optional()
-            .describe('Custom blend time (-1 for default)'),
-        custom_speed: z
-            .number()
-            .optional()
-            .describe('Custom playback speed (1.0 default)'),
-        from_end: z.boolean().optional().describe('Play from end (for reverse)'),
-    }),
-    async execute({ node_path, animation_name, custom_blend, custom_speed, from_end }, { godot }) {
-        const result = await godot.sendCommand('play_animation', {
-            node_path,
-            animation_name,
-            custom_blend,
-            custom_speed,
-            from_end,
-        });
-        return `Playing animation: ${result.playing}`;
-    },
-});
-export const stopAnimation = defineTool({
-    name: 'stop_animation',
-    description: 'Stop current animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        keep_state: z
-            .boolean()
-            .optional()
-            .describe('Keep current animation state (default false)'),
-    }),
-    async execute({ node_path, keep_state }, { godot }) {
-        await godot.sendCommand('stop_animation', { node_path, keep_state });
-        return 'Animation stopped';
-    },
-});
-export const pauseAnimation = defineTool({
-    name: 'pause_animation',
-    description: 'Pause/unpause animation playback',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        paused: z.boolean().describe('True to pause, false to unpause'),
-    }),
-    async execute({ node_path, paused }, { godot }) {
-        await godot.sendCommand('pause_animation', { node_path, paused });
-        return paused ? 'Animation paused' : 'Animation unpaused';
-    },
-});
-export const seekAnimation = defineTool({
-    name: 'seek_animation',
-    description: 'Seek to a specific position in the animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        seconds: z.number().describe('Position to seek to'),
-        update: z
-            .boolean()
-            .optional()
-            .describe('Update node immediately (default true)'),
-    }),
-    async execute({ node_path, seconds, update }, { godot }) {
-        const result = await godot.sendCommand('seek_animation', { node_path, seconds, update });
-        return `Seeked to position: ${result.position}`;
-    },
-});
-export const queueAnimation = defineTool({
-    name: 'queue_animation',
-    description: 'Queue an animation to play after current one finishes',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to queue'),
-    }),
-    async execute({ node_path, animation_name }, { godot }) {
-        const result = await godot.sendCommand('queue_animation', { node_path, animation_name });
-        return `Queued animation: ${result.queued} (queue length: ${result.queue_length})`;
-    },
-});
-export const clearAnimationQueue = defineTool({
-    name: 'clear_animation_queue',
-    description: 'Clear the animation queue',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-    }),
-    async execute({ node_path }, { godot }) {
-        await godot.sendCommand('clear_animation_queue', { node_path });
-        return 'Animation queue cleared';
-    },
-});
-export const createAnimation = defineTool({
-    name: 'create_animation',
-    description: 'Create a new animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Name for new animation'),
-        library_name: z
-            .string()
-            .optional()
-            .describe('Library to add to (default "")'),
-        length: z
-            .number()
-            .optional()
-            .describe('Animation length in seconds (default 1.0)'),
-        loop_mode: z
-            .enum(['none', 'linear', 'pingpong'])
-            .optional()
-            .describe('Loop mode (default "none")'),
-        step: z.number().optional().describe('Step value for keyframe snapping'),
-    }),
-    async execute({ node_path, animation_name, library_name, length, loop_mode, step }, { godot }) {
-        const result = await godot.sendCommand('create_animation', { node_path, animation_name, library_name, length, loop_mode, step });
-        return `Created animation: ${result.created}${result.library ? ` in library: ${result.library}` : ''}`;
-    },
-});
-export const deleteAnimation = defineTool({
-    name: 'delete_animation',
-    description: 'Delete an animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to delete'),
-        library_name: z
-            .string()
-            .optional()
-            .describe('Library containing animation'),
-    }),
-    async execute({ node_path, animation_name, library_name }, { godot }) {
-        const result = await godot.sendCommand('delete_animation', { node_path, animation_name, library_name });
-        return `Deleted animation: ${result.deleted}`;
-    },
-});
-export const renameAnimation = defineTool({
-    name: 'rename_animation',
-    description: 'Rename an animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        old_name: z.string().describe('Current animation name'),
-        new_name: z.string().describe('New animation name'),
-        library_name: z
-            .string()
-            .optional()
-            .describe('Library containing animation'),
-    }),
-    async execute({ node_path, old_name, new_name, library_name }, { godot }) {
-        const result = await godot.sendCommand('rename_animation', { node_path, old_name, new_name, library_name });
-        return `Renamed animation: ${result.renamed.from} -> ${result.renamed.to}`;
-    },
-});
-export const updateAnimationProperties = defineTool({
-    name: 'update_animation_properties',
-    description: 'Update animation properties (length, loop mode, step)',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to update'),
-        length: z.number().optional().describe('New length'),
-        loop_mode: z
-            .enum(['none', 'linear', 'pingpong'])
-            .optional()
-            .describe('New loop mode'),
-        step: z.number().optional().describe('New step value'),
-    }),
-    async execute({ node_path, animation_name, length, loop_mode, step }, { godot }) {
-        const result = await godot.sendCommand('update_animation_properties', {
-            node_path,
-            animation_name,
-            length,
-            loop_mode,
-            step,
-        });
-        return `Updated animation: ${result.updated}\nProperties: ${JSON.stringify(result.properties)}`;
-    },
-});
-export const addAnimationTrack = defineTool({
-    name: 'add_animation_track',
-    description: 'Add a new track to an animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to modify'),
-        track_type: z
-            .enum([
-            'value',
-            'position_3d',
-            'rotation_3d',
-            'scale_3d',
-            'blend_shape',
-            'method',
-            'bezier',
-            'audio',
-            'animation',
-        ])
-            .describe('Type of track'),
-        track_path: z
-            .string()
-            .describe('Node path and property (e.g., "Sprite2D:frame")'),
-        insert_at: z
-            .number()
-            .optional()
-            .describe('Track index to insert at (-1 for end)'),
-    }),
-    async execute({ node_path, animation_name, track_type, track_path, insert_at }, { godot }) {
-        const result = await godot.sendCommand('add_animation_track', {
-            node_path,
-            animation_name,
-            track_type,
-            track_path,
-            insert_at,
-        });
-        return `Added track ${result.track_index}: ${result.track_type} -> ${result.track_path}`;
-    },
-});
-export const removeAnimationTrack = defineTool({
-    name: 'remove_animation_track',
-    description: 'Remove a track from an animation',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to modify'),
-        track_index: z.number().describe('Index of track to remove'),
-    }),
-    async execute({ node_path, animation_name, track_index }, { godot }) {
-        const result = await godot.sendCommand('remove_animation_track', { node_path, animation_name, track_index });
-        return `Removed track: ${result.removed_track}`;
-    },
-});
-export const addKeyframe = defineTool({
-    name: 'add_keyframe',
-    description: 'Add a keyframe to a track',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to modify'),
-        track_index: z.number().describe('Track index'),
-        time: z.number().describe('Keyframe time in seconds'),
-        value: z.unknown().describe('Keyframe value (type depends on track type)'),
-        transition: z
-            .number()
-            .optional()
-            .describe('Transition curve (1.0 = linear)'),
-        method_name: z
-            .string()
-            .optional()
-            .describe('Method name (for method tracks)'),
-        args: z.array(z.unknown()).optional().describe('Method arguments'),
-    }),
-    async execute({ node_path, animation_name, track_index, time, value, transition, method_name, args, }, { godot }) {
-        const result = await godot.sendCommand('add_keyframe', {
-            node_path,
-            animation_name,
-            track_index,
-            time,
-            value,
-            transition,
-            method_name,
-            args,
-        });
-        return `Added keyframe ${result.keyframe_index} at ${result.time}s`;
-    },
-});
-export const removeKeyframe = defineTool({
-    name: 'remove_keyframe',
-    description: 'Remove a keyframe from a track',
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to modify'),
-        track_index: z.number().describe('Track index'),
-        keyframe_index: z.number().describe('Index of keyframe to remove'),
-    }),
-    async execute({ node_path, animation_name, track_index, keyframe_index }, { godot }) {
-        const result = await godot.sendCommand('remove_keyframe', {
-            node_path,
-            animation_name,
-            track_index,
-            keyframe_index,
-        });
-        return `Removed keyframe ${result.removed_keyframe} from track ${result.track_index}`;
+const AnimationPlaybackSchema = z
+    .object({
+    action: z
+        .enum(['play', 'stop', 'pause', 'seek', 'queue', 'clear_queue'])
+        .describe('Action: play, stop, pause, seek, queue, clear_queue'),
+    node_path: z.string().describe('Path to AnimationPlayer'),
+    animation_name: z.string().optional().describe('Animation name (play, queue)'),
+    custom_blend: z.number().optional().describe('Custom blend time, -1 for default (play)'),
+    custom_speed: z.number().optional().describe('Playback speed, 1.0 default (play)'),
+    from_end: z.boolean().optional().describe('Play from end for reverse (play)'),
+    keep_state: z.boolean().optional().describe('Keep current animation state (stop)'),
+    paused: z.boolean().optional().describe('True to pause, false to unpause (pause)'),
+    seconds: z.number().optional().describe('Position to seek to (seek)'),
+    update: z.boolean().optional().describe('Update node immediately, default true (seek)'),
+})
+    .refine((data) => {
+    switch (data.action) {
+        case 'play':
+        case 'queue':
+            return !!data.animation_name;
+        case 'stop':
+        case 'clear_queue':
+            return true;
+        case 'pause':
+            return data.paused !== undefined;
+        case 'seek':
+            return data.seconds !== undefined;
+    }
+}, { message: 'Missing required fields for action' });
+export const animationPlayback = defineTool({
+    name: 'animation_playback',
+    description: 'Control animation playback. Actions: play, stop, pause, seek, queue, clear_queue',
+    schema: AnimationPlaybackSchema,
+    async execute(args, { godot }) {
+        switch (args.action) {
+            case 'play': {
+                const result = await godot.sendCommand('play_animation', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    custom_blend: args.custom_blend,
+                    custom_speed: args.custom_speed,
+                    from_end: args.from_end,
+                });
+                return `Playing animation: ${result.playing}`;
+            }
+            case 'stop': {
+                await godot.sendCommand('stop_animation', {
+                    node_path: args.node_path,
+                    keep_state: args.keep_state,
+                });
+                return 'Animation stopped';
+            }
+            case 'pause': {
+                await godot.sendCommand('pause_animation', {
+                    node_path: args.node_path,
+                    paused: args.paused,
+                });
+                return args.paused ? 'Animation paused' : 'Animation unpaused';
+            }
+            case 'seek': {
+                const result = await godot.sendCommand('seek_animation', {
+                    node_path: args.node_path,
+                    seconds: args.seconds,
+                    update: args.update,
+                });
+                return `Seeked to position: ${result.position}`;
+            }
+            case 'queue': {
+                const result = await godot.sendCommand('queue_animation', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                });
+                return `Queued animation: ${result.queued} (queue length: ${result.queue_length})`;
+            }
+            case 'clear_queue': {
+                await godot.sendCommand('clear_animation_queue', { node_path: args.node_path });
+                return 'Animation queue cleared';
+            }
+        }
     },
 });
-export const updateKeyframe = defineTool({
-    name: 'update_keyframe',
-    description: "Update an existing keyframe's value or time",
-    schema: z.object({
-        node_path: z.string().describe('Path to AnimationPlayer'),
-        animation_name: z.string().describe('Animation to modify'),
-        track_index: z.number().describe('Track index'),
-        keyframe_index: z.number().describe('Keyframe index'),
-        time: z.number().optional().describe('New time'),
-        value: z.unknown().optional().describe('New value'),
-        transition: z.number().optional().describe('New transition curve'),
-    }),
-    async execute({ node_path, animation_name, track_index, keyframe_index, time, value, transition, }, { godot }) {
-        const result = await godot.sendCommand('update_keyframe', {
-            node_path,
-            animation_name,
-            track_index,
-            keyframe_index,
-            time,
-            value,
-            transition,
-        });
-        return `Updated keyframe ${result.updated_keyframe}: ${JSON.stringify(result.changes)}`;
+const LoopModeEnum = z.enum(['none', 'linear', 'pingpong']);
+const TrackTypeEnum = z.enum([
+    'value',
+    'position_3d',
+    'rotation_3d',
+    'scale_3d',
+    'blend_shape',
+    'method',
+    'bezier',
+    'audio',
+    'animation',
+]);
+const AnimationEditSchema = z
+    .object({
+    action: z
+        .enum([
+        'create',
+        'delete',
+        'rename',
+        'update_props',
+        'add_track',
+        'remove_track',
+        'add_keyframe',
+        'remove_keyframe',
+        'update_keyframe',
+    ])
+        .describe('Action: create, delete, rename, update_props, add_track, remove_track, add_keyframe, remove_keyframe, update_keyframe'),
+    node_path: z.string().describe('Path to AnimationPlayer'),
+    animation_name: z.string().optional().describe('Animation name (most actions)'),
+    library_name: z.string().optional().describe('Library name (create, delete, rename)'),
+    length: z.number().optional().describe('Animation length in seconds (create, update_props)'),
+    loop_mode: LoopModeEnum.optional().describe('Loop mode: none, linear, pingpong (create, update_props)'),
+    step: z.number().optional().describe('Step value for keyframe snapping (create, update_props)'),
+    old_name: z.string().optional().describe('Current animation name (rename)'),
+    new_name: z.string().optional().describe('New animation name (rename)'),
+    track_type: TrackTypeEnum.optional().describe('Type of track (add_track)'),
+    track_path: z.string().optional().describe('Node path and property, e.g. "Sprite2D:frame" (add_track)'),
+    insert_at: z.number().optional().describe('Track index to insert at, -1 for end (add_track)'),
+    track_index: z.number().optional().describe('Track index (remove_track, add/remove/update_keyframe)'),
+    time: z.number().optional().describe('Keyframe time in seconds (add_keyframe, update_keyframe)'),
+    value: z.unknown().optional().describe('Keyframe value (add_keyframe, update_keyframe)'),
+    transition: z.number().optional().describe('Transition curve, 1.0 = linear (add_keyframe, update_keyframe)'),
+    method_name: z.string().optional().describe('Method name for method tracks (add_keyframe)'),
+    args: z.array(z.unknown()).optional().describe('Method arguments (add_keyframe)'),
+    keyframe_index: z.number().optional().describe('Keyframe index (remove_keyframe, update_keyframe)'),
+})
+    .refine((data) => {
+    switch (data.action) {
+        case 'create':
+            return !!data.animation_name;
+        case 'delete':
+            return !!data.animation_name;
+        case 'rename':
+            return !!data.old_name && !!data.new_name;
+        case 'update_props':
+            return !!data.animation_name;
+        case 'add_track':
+            return !!data.animation_name && !!data.track_type && !!data.track_path;
+        case 'remove_track':
+            return !!data.animation_name && data.track_index !== undefined;
+        case 'add_keyframe':
+            return !!data.animation_name && data.track_index !== undefined && data.time !== undefined;
+        case 'remove_keyframe':
+            return (!!data.animation_name && data.track_index !== undefined && data.keyframe_index !== undefined);
+        case 'update_keyframe':
+            return (!!data.animation_name && data.track_index !== undefined && data.keyframe_index !== undefined);
+    }
+}, { message: 'Missing required fields for action' });
+export const animationEdit = defineTool({
+    name: 'animation_edit',
+    description: 'Edit animations. Actions: create, delete, rename, update_props, add_track, remove_track, add_keyframe, remove_keyframe, update_keyframe',
+    schema: AnimationEditSchema,
+    async execute(args, { godot }) {
+        switch (args.action) {
+            case 'create': {
+                const result = await godot.sendCommand('create_animation', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    library_name: args.library_name,
+                    length: args.length,
+                    loop_mode: args.loop_mode,
+                    step: args.step,
+                });
+                return `Created animation: ${result.created}${result.library ? ` in library: ${result.library}` : ''}`;
+            }
+            case 'delete': {
+                const result = await godot.sendCommand('delete_animation', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    library_name: args.library_name,
+                });
+                return `Deleted animation: ${result.deleted}`;
+            }
+            case 'rename': {
+                const result = await godot.sendCommand('rename_animation', {
+                    node_path: args.node_path,
+                    old_name: args.old_name,
+                    new_name: args.new_name,
+                    library_name: args.library_name,
+                });
+                return `Renamed animation: ${result.renamed.from} -> ${result.renamed.to}`;
+            }
+            case 'update_props': {
+                const result = await godot.sendCommand('update_animation_properties', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    length: args.length,
+                    loop_mode: args.loop_mode,
+                    step: args.step,
+                });
+                return `Updated animation: ${result.updated}\nProperties: ${JSON.stringify(result.properties)}`;
+            }
+            case 'add_track': {
+                const result = await godot.sendCommand('add_animation_track', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_type: args.track_type,
+                    track_path: args.track_path,
+                    insert_at: args.insert_at,
+                });
+                return `Added track ${result.track_index}: ${result.track_type} -> ${result.track_path}`;
+            }
+            case 'remove_track': {
+                const result = await godot.sendCommand('remove_animation_track', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_index: args.track_index,
+                });
+                return `Removed track: ${result.removed_track}`;
+            }
+            case 'add_keyframe': {
+                const result = await godot.sendCommand('add_keyframe', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_index: args.track_index,
+                    time: args.time,
+                    value: args.value,
+                    transition: args.transition,
+                    method_name: args.method_name,
+                    args: args.args,
+                });
+                return `Added keyframe ${result.keyframe_index} at ${result.time}s`;
+            }
+            case 'remove_keyframe': {
+                const result = await godot.sendCommand('remove_keyframe', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_index: args.track_index,
+                    keyframe_index: args.keyframe_index,
+                });
+                return `Removed keyframe ${result.removed_keyframe} from track ${result.track_index}`;
+            }
+            case 'update_keyframe': {
+                const result = await godot.sendCommand('update_keyframe', {
+                    node_path: args.node_path,
+                    animation_name: args.animation_name,
+                    track_index: args.track_index,
+                    keyframe_index: args.keyframe_index,
+                    time: args.time,
+                    value: args.value,
+                    transition: args.transition,
+                });
+                return `Updated keyframe ${result.updated_keyframe}: ${JSON.stringify(result.changes)}`;
+            }
+        }
     },
 });
-export const animationTools = [
-    listAnimationPlayers,
-    getAnimationPlayerInfo,
-    getAnimationDetails,
-    getTrackKeyframes,
-    playAnimation,
-    stopAnimation,
-    pauseAnimation,
-    seekAnimation,
-    queueAnimation,
-    clearAnimationQueue,
-    createAnimation,
-    deleteAnimation,
-    renameAnimation,
-    updateAnimationProperties,
-    addAnimationTrack,
-    removeAnimationTrack,
-    addKeyframe,
-    removeKeyframe,
-    updateKeyframe,
-];
+export const animationTools = [animationQuery, animationPlayback, animationEdit];
 //# sourceMappingURL=animation.js.map