@skillcap/gdh 4.0.0 → 4.1.0

package/node_modules/@gdh/mcp/dist/index.js

@@ -428,9 +428,600 @@ const TOOL_MANIFEST = [
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
+    {
+        name: "editor.animation.player.inspect",
+        summary: "Inspect an AnimationPlayer or AnimationMixer node in a saved scene, including libraries, clips, autoplay, and blend metadata.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation player inspection request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.read",
+        summary: "Read one AnimationPlayer clip through Godot APIs, including tracks and optionally bounded keyframe data.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip read request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            includeKeys: {
+                type: "boolean",
+                description: "When true, include bounded keyframe data for each returned track.",
+            },
+            keyLimit: {
+                type: "number",
+                description: "Optional positive keyframe limit across each track.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.create",
+        summary: "Create or overwrite one AnimationPlayer clip in an AnimationLibrary through Godot editor APIs.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip create request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            length: {
+                type: "number",
+                description: "Optional animation length in seconds. Defaults to 1.0.",
+            },
+            step: {
+                type: "number",
+                description: "Optional animation step in seconds.",
+            },
+            loopMode: {
+                type: ["string", "number"],
+                description: "Optional loop mode: none, linear, pingpong, or a Godot numeric value.",
+            },
+            overwrite: {
+                type: "boolean",
+                description: "When true, replace an existing clip with the same name.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.delete",
+        summary: "Delete one AnimationPlayer clip from an AnimationLibrary through Godot editor APIs.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.track.add",
+        summary: "Add a typed Animation track to one clip, using Godot track types and a NodePath such as Sprite2D:modulate:a.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation track add request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackType: {
+                type: ["string", "number"],
+                description: "Optional Godot Animation track type. Use value, position_3d, rotation_3d, scale_3d, blend_shape, method, bezier, audio, or animation. Defaults to value.",
+            },
+            trackPath: {
+                type: "string",
+                description: "Required Animation track NodePath, relative to the AnimationPlayer root.",
+            },
+            atPosition: {
+                type: "number",
+                description: "Optional zero-based insertion position. Defaults to appending the track.",
+            },
+            interpolation: {
+                type: ["string", "number"],
+                description: "Optional interpolation: nearest, linear, cubic, linear_angle, cubic_angle, or a Godot numeric value.",
+            },
+            updateMode: {
+                type: ["string", "number"],
+                description: "Optional value-track update mode: continuous, discrete, capture, or a Godot numeric value.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackPath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.track.remove",
+        summary: "Remove one track from an AnimationPlayer clip by zero-based track index.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation track remove request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.keyframe.upsert",
+        summary: "Insert or replace one keyframe on an Animation track. Values use GDH's encoded Variant shape for vectors, colors, resources, and scalars.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation keyframe upsert request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            time: {
+                type: "number",
+                description: "Required key time in seconds.",
+            },
+            value: {
+                type: ["string", "number", "boolean", "object", "array"],
+                description: "Required key value as a JSON-serializable Godot Variant encoding.",
+                additionalProperties: true,
+            },
+            transition: {
+                type: "number",
+                description: "Optional key transition value. Defaults to 1.0.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex", "time", "value"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.keyframe.delete",
+        summary: "Delete one keyframe from an Animation track by key index or key time.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation keyframe delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            keyIndex: {
+                type: "number",
+                description: "Optional zero-based key index. Provide keyIndex or time.",
+            },
+            time: {
+                type: "number",
+                description: "Optional key time in seconds. Provide keyIndex or time.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.create",
+        summary: "Create an AnimationNodeStateMachine tree_root on an AnimationTree node through Godot editor APIs.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine create request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            overwrite: {
+                type: "boolean",
+                description: "When true, replace an existing AnimationNodeStateMachine tree_root.",
+            },
+            properties: {
+                type: "object",
+                description: "Optional properties to set on the AnimationNodeStateMachine resource.",
+                additionalProperties: true,
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.read",
+        summary: "Read an AnimationTree state-machine graph as compact nodes and transitions without automating the editor UI.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine graph read request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree with an AnimationNodeStateMachine tree_root.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.node.upsert",
+        summary: "Create or update one node in an AnimationTree state-machine graph without automating the editor UI.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine node upsert request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            stateName: {
+                type: "string",
+                description: "Required state-machine node name.",
+            },
+            nodeType: {
+                type: "string",
+                description: "Optional AnimationNode type. Defaults to AnimationNodeAnimation.",
+            },
+            position: {
+                type: "object",
+                description: 'Optional graph position encoded as {"$vector2":{"x":0,"y":0}}.',
+                additionalProperties: true,
+            },
+            properties: {
+                type: "object",
+                description: 'Optional properties to set on the AnimationNode, for example {"animation":"idle"}.',
+                additionalProperties: true,
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath", "stateName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.node.delete",
+        summary: "Delete one node from an AnimationTree state-machine graph.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine node delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            stateName: {
+                type: "string",
+                description: "Required state-machine node name.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath", "stateName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.transition.upsert",
+        summary: "Create or replace one transition in an AnimationTree state-machine graph without automating the editor UI.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine transition upsert request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            fromState: {
+                type: "string",
+                description: "Required source state name.",
+            },
+            toState: {
+                type: "string",
+                description: "Required target state name.",
+            },
+            properties: {
+                type: "object",
+                description: "Optional properties to set on the transition resource.",
+                additionalProperties: true,
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath", "fromState", "toState"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.state_machine.transition.delete",
+        summary: "Delete one transition from an AnimationTree state-machine graph.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation state-machine transition delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            fromState: {
+                type: "string",
+                description: "Required source state name.",
+            },
+            toState: {
+                type: "string",
+                description: "Required target state name.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath", "fromState", "toState"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
     {
         name: "editor.operation.run",
-        summary: "Advanced escape hatch for one targeted Godot-native editor operation. Prefer focused editor.* tools for normal reads. Payloads dispatch on operation.kind, not type.",
+        summary: "Advanced escape hatch for one targeted Godot-native editor operation. Prefer focused editor.* tools for normal reads and common writes. Payloads dispatch on operation.kind, not type.",
         targetPathPolicy: "optional",
         inputSchema: defineObjectSchema("Editor Bridge operation request.", {
             operation: {
@@ -697,6 +1288,129 @@ async function invokeMcpToolWithContext(request, context) {
                     propertyQuery: readOptionalString(request.input["propertyQuery"], "propertyQuery"),
                     propertyLimit: readOptionalPositiveInteger(request.input["propertyLimit"], "propertyLimit"),
                 })));
+            case "editor.animation.player.inspect":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.player.inspect", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                })));
+            case "editor.animation.clip.read":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.read", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    includeKeys: readOptionalBoolean(request.input["includeKeys"], "includeKeys"),
+                    keyLimit: readOptionalPositiveInteger(request.input["keyLimit"], "keyLimit"),
+                })));
+            case "editor.animation.clip.create":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.create", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    length: readOptionalNumber(request.input["length"], "length"),
+                    step: readOptionalNumber(request.input["step"], "step"),
+                    loopMode: readOptionalStringOrNumber(request.input["loopMode"], "loopMode"),
+                    overwrite: readOptionalBoolean(request.input["overwrite"], "overwrite"),
+                })));
+            case "editor.animation.clip.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                })));
+            case "editor.animation.track.add":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.track.add", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackType: readOptionalStringOrNumber(request.input["trackType"], "trackType") ?? "value",
+                    trackPath: requireString(request.input["trackPath"], "trackPath"),
+                    atPosition: readOptionalNumber(request.input["atPosition"], "atPosition"),
+                    interpolation: readOptionalStringOrNumber(request.input["interpolation"], "interpolation"),
+                    updateMode: readOptionalStringOrNumber(request.input["updateMode"], "updateMode"),
+                })));
+            case "editor.animation.track.remove":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.track.remove", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                })));
+            case "editor.animation.keyframe.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.keyframe.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                    time: requireNumber(request.input["time"], "time"),
+                    value: requireJsonValue(request.input["value"], "value"),
+                    transition: readOptionalNumber(request.input["transition"], "transition"),
+                })));
+            case "editor.animation.keyframe.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.keyframe.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                    keyIndex: readOptionalNumber(request.input["keyIndex"], "keyIndex"),
+                    time: readOptionalNumber(request.input["time"], "time"),
+                })));
+            case "editor.animation.state_machine.create":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.create", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    overwrite: readOptionalBoolean(request.input["overwrite"], "overwrite"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.read":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.read", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                })));
+            case "editor.animation.state_machine.node.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.node.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    stateName: requireString(request.input["stateName"], "stateName"),
+                    nodeType: readOptionalString(request.input["nodeType"], "nodeType"),
+                    position: request.input["position"] === undefined
+                        ? undefined
+                        : requireJsonValue(request.input["position"], "position"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.node.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.node.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    stateName: requireString(request.input["stateName"], "stateName"),
+                })));
+            case "editor.animation.state_machine.transition.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.transition.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    fromState: requireString(request.input["fromState"], "fromState"),
+                    toState: requireString(request.input["toState"], "toState"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.transition.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.transition.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    fromState: requireString(request.input["fromState"], "fromState"),
+                    toState: requireString(request.input["toState"], "toState"),
+                })));
             case "editor.operation.run":
                 return succeeded(request.toolName, targetPath, await invokeEditorOperationRunTool(targetPath, request.input));
             case "bridge.entry.list":
@@ -1083,6 +1797,15 @@ function readOptionalString(value, fieldName) {
     }
     return value;
 }
+function readOptionalStringOrNumber(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(`MCP input field "${fieldName}" must be a string or number.`);
+    }
+    return value;
+}
 function readOptionalEditorSessionMode(value, fieldName) {
     const mode = readOptionalString(value, fieldName);
     if (mode === null || mode === "auto")
@@ -1102,6 +1825,28 @@ function requireString(value, fieldName) {
     }
     return stringValue;
 }
+function readOptionalNumber(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number") {
+        throw new Error(`MCP input field "${fieldName}" must be a number.`);
+    }
+    return value;
+}
+function requireNumber(value, fieldName) {
+    const numberValue = readOptionalNumber(value, fieldName);
+    if (numberValue === undefined) {
+        throw new Error(`MCP input field "${fieldName}" is required.`);
+    }
+    return numberValue;
+}
+function requireJsonValue(value, fieldName) {
+    if (value === undefined) {
+        throw new Error(`MCP input field "${fieldName}" is required.`);
+    }
+    return value;
+}
 function requireObject(value, fieldName) {
     if (value === undefined) {
         throw new Error(`MCP input field "${fieldName}" is required.`);