ue-mcp 1.3.8-beta.13 → 1.3.8-beta.14

package/dist/tool-counts.json

@@ -33,6 +33,6 @@
   },
   "nativeToolsets": 0,
   "nativeToolActions": 0,
-  "generatedAt": "2026-09-10T04:36:36.698Z",
-  "version": "1.3.8-beta.13"
+  "generatedAt": "2026-09-10T16:45:03.586Z",
+  "version": "1.3.8-beta.14"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ue-mcp",
-  "version": "1.3.8-beta.13",
+  "version": "1.3.8-beta.14",
   "description": "Unreal Engine MCP server - 26 tools, 1930+ actions for AI-driven editor control",
   "type": "module",
   "main": "dist/index.js",

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/HandlerJsonProperty.h

@@ -10,7 +10,7 @@
 #include "UObject/UnrealType.h"
 #include "UObject/PropertyPortFlags.h"
 #include "UObject/SoftObjectPtr.h"
-#include "StructUtils/InstancedStruct.h"
+#include "MCPEngineCompat.h"
 #include "GameplayTagContainer.h"
 #include "GameplayTagsManager.h"
 #include "Engine/Blueprint.h"

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/HandlerPoseSearchSchema.h

@@ -19,9 +19,37 @@
 #include "CoreMinimal.h"
 #include "UObject/UnrealType.h"
 #include "PoseSearch/PoseSearchSchema.h"
+#include "HandlerUtils.h"
 
 namespace MCPPoseSearch
 {
+	/** The schema's per-role skeletons.
+	 *
+	 *  5.5 added GetRoledSkeletons(). On 5.4 the Skeletons array is private
+	 *  with no accessor at all, so it is read through the property system -
+	 *  FPoseSearchRoledSkeleton itself is public there, only the member is not.
+	 *  Returned by value so both engines present the same signature; the
+	 *  callers are read paths over a handful of roles. */
+	inline TArray<FPoseSearchRoledSkeleton> RoledSkeletons(const UPoseSearchSchema* Schema)
+	{
+		TArray<FPoseSearchRoledSkeleton> Out;
+		if (!Schema) return Out;
+#if UE_MCP_HAS_5_5_API
+		Out = Schema->GetRoledSkeletons();
+#else
+		if (const FArrayProperty* Prop = FindFProperty<FArrayProperty>(UPoseSearchSchema::StaticClass(), TEXT("Skeletons")))
+		{
+			FScriptArrayHelper Helper(Prop, Prop->ContainerPtrToValuePtr<void>(Schema));
+			Out.Reserve(Helper.Num());
+			for (int32 Index = 0; Index < Helper.Num(); ++Index)
+			{
+				Out.Add(*reinterpret_cast<const FPoseSearchRoledSkeleton*>(Helper.GetRawPtr(Index)));
+			}
+		}
+#endif
+		return Out;
+	}
+
 	/** Recompute FinalizedChannels and SchemaCardinality after a channel or
 	 *  skeleton edit. Finalize() itself is private; PostEditChangeProperty is
 	 *  the public door onto it. */
@@ -44,7 +72,7 @@ namespace MCPPoseSearch
 		TArray<FString> Problems;
 
 		bool bHasSkeleton = false;
-		for (const FPoseSearchRoledSkeleton& Roled : Schema->GetRoledSkeletons())
+		for (const FPoseSearchRoledSkeleton& Roled : RoledSkeletons(Schema))
 		{
 			if (Roled.Skeleton)
 			{

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_Depth.cpp

@@ -282,7 +282,17 @@ TSharedPtr<FJsonValue> FAnimationHandlers::SetStateMachineEntry(const TSharedPtr
 			TEXT("Recreate it with animation(create_state_machine)."), *SMName));
 	}
 
+#if UE_MCP_HAS_5_5_API
 	UEdGraphPin* EntryPin = Entry->GetOutputPin();
+#else
+	// 5.4's UAnimStateEntryNode has no GetOutputPin(); the entry node allocates
+	// exactly one output pin, which is the same pin that accessor returns.
+	UEdGraphPin* EntryPin = nullptr;
+	for (UEdGraphPin* Pin : Entry->Pins)
+	{
+		if (Pin && Pin->Direction == EGPD_Output) { EntryPin = Pin; break; }
+	}
+#endif
 	if (!EntryPin)
 	{
 		return MCPError(TEXT("The state machine's entry node has no output pin."));

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_IKRigAuthoring.cpp

@@ -14,7 +14,7 @@
 #include "RigEditor/IKRigAutoCharacterizer.h"
 #include "RigEditor/IKRigController.h"
 #include "ScopedTransaction.h"
-#include "StructUtils/InstancedStruct.h"
+#include "MCPEngineCompat.h"
 #endif
 
 namespace UE_MCP_IKRigAuthoring

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_MotionMatching.cpp

@@ -15,8 +15,17 @@
 #include "PoseSearch/PoseSearchSchema.h"
 #include "HandlerPoseSearchSchema.h"
 #include "PoseSearch/PoseSearchFeatureChannel.h"
+#if UE_MCP_HAS_5_5_API
 #include "PoseSearch/PoseSearchFeatureChannel_Pose.h"
 #include "PoseSearch/PoseSearchFeatureChannel_Trajectory.h"
+#else
+// UE 5.4 keeps both channel headers (and the FPoseSearchBone /
+// FPoseSearchTrajectorySample structs inside them) private to the PoseSearch
+// module, so nothing outside it can name the types. The classes are still
+// UCLASSes with reflected properties, so the two channel actions author them
+// through the property system instead - same asset, same fields, no header.
+#include "HandlerJsonProperty.h"
+#endif
 #include "PoseSearch/PoseSearchDatabase.h"
 #include "PoseSearch/PoseSearchNormalizationSet.h"
 #include "Animation/MirrorDataTable.h"
@@ -63,13 +72,47 @@ static int32 ParseFlagArray(const TSharedPtr<FJsonObject>& Obj, const TCHAR* Fie
 	return Flags == 0 ? Default : Flags;
 }
 
+// Bit values of EPoseSearchBoneFlags / EPoseSearchTrajectoryFlags. They are
+// spelled out rather than taken from the enums because on 5.4 the enums are
+// declared in the private channel headers; these are the values the asset
+// serializes and they are the same from 5.4 through 5.8.
+static constexpr int32 MCPBoneFlagVelocity = 1 << 0;
+static constexpr int32 MCPBoneFlagPosition = 1 << 1;
+static constexpr int32 MCPBoneFlagRotation = 1 << 2;
+static constexpr int32 MCPBoneFlagPhase    = 1 << 3;
+
+static constexpr int32 MCPTrajFlagVelocity            = 1 << 0;
+static constexpr int32 MCPTrajFlagPosition            = 1 << 1;
+static constexpr int32 MCPTrajFlagVelocityDirection   = 1 << 2;
+static constexpr int32 MCPTrajFlagFacingDirection     = 1 << 3;
+static constexpr int32 MCPTrajFlagVelocityXY          = 1 << 4;
+static constexpr int32 MCPTrajFlagPositionXY          = 1 << 5;
+static constexpr int32 MCPTrajFlagVelocityDirectionXY = 1 << 6;
+static constexpr int32 MCPTrajFlagFacingDirectionXY   = 1 << 7;
+
+#if UE_MCP_HAS_5_5_API
+// Where the enums are reachable, hold the spelled-out values to them.
+static_assert(MCPBoneFlagVelocity == int32(EPoseSearchBoneFlags::Velocity), "EPoseSearchBoneFlags::Velocity moved");
+static_assert(MCPBoneFlagPosition == int32(EPoseSearchBoneFlags::Position), "EPoseSearchBoneFlags::Position moved");
+static_assert(MCPBoneFlagRotation == int32(EPoseSearchBoneFlags::Rotation), "EPoseSearchBoneFlags::Rotation moved");
+static_assert(MCPBoneFlagPhase == int32(EPoseSearchBoneFlags::Phase), "EPoseSearchBoneFlags::Phase moved");
+static_assert(MCPTrajFlagVelocity == int32(EPoseSearchTrajectoryFlags::Velocity), "EPoseSearchTrajectoryFlags::Velocity moved");
+static_assert(MCPTrajFlagPosition == int32(EPoseSearchTrajectoryFlags::Position), "EPoseSearchTrajectoryFlags::Position moved");
+static_assert(MCPTrajFlagVelocityDirection == int32(EPoseSearchTrajectoryFlags::VelocityDirection), "EPoseSearchTrajectoryFlags::VelocityDirection moved");
+static_assert(MCPTrajFlagFacingDirection == int32(EPoseSearchTrajectoryFlags::FacingDirection), "EPoseSearchTrajectoryFlags::FacingDirection moved");
+static_assert(MCPTrajFlagVelocityXY == int32(EPoseSearchTrajectoryFlags::VelocityXY), "EPoseSearchTrajectoryFlags::VelocityXY moved");
+static_assert(MCPTrajFlagPositionXY == int32(EPoseSearchTrajectoryFlags::PositionXY), "EPoseSearchTrajectoryFlags::PositionXY moved");
+static_assert(MCPTrajFlagVelocityDirectionXY == int32(EPoseSearchTrajectoryFlags::VelocityDirectionXY), "EPoseSearchTrajectoryFlags::VelocityDirectionXY moved");
+static_assert(MCPTrajFlagFacingDirectionXY == int32(EPoseSearchTrajectoryFlags::FacingDirectionXY), "EPoseSearchTrajectoryFlags::FacingDirectionXY moved");
+#endif
+
 static const TMap<FString, int32>& BoneFlagTable()
 {
 	static const TMap<FString, int32> Table = {
-		{ TEXT("velocity"), int32(EPoseSearchBoneFlags::Velocity) },
-		{ TEXT("position"), int32(EPoseSearchBoneFlags::Position) },
-		{ TEXT("rotation"), int32(EPoseSearchBoneFlags::Rotation) },
-		{ TEXT("phase"),    int32(EPoseSearchBoneFlags::Phase) },
+		{ TEXT("velocity"), MCPBoneFlagVelocity },
+		{ TEXT("position"), MCPBoneFlagPosition },
+		{ TEXT("rotation"), MCPBoneFlagRotation },
+		{ TEXT("phase"),    MCPBoneFlagPhase },
 	};
 	return Table;
 }
@@ -77,18 +120,36 @@ static const TMap<FString, int32>& BoneFlagTable()
 static const TMap<FString, int32>& TrajectoryFlagTable()
 {
 	static const TMap<FString, int32> Table = {
-		{ TEXT("velocity"),            int32(EPoseSearchTrajectoryFlags::Velocity) },
-		{ TEXT("position"),            int32(EPoseSearchTrajectoryFlags::Position) },
-		{ TEXT("velocitydirection"),   int32(EPoseSearchTrajectoryFlags::VelocityDirection) },
-		{ TEXT("facingdirection"),     int32(EPoseSearchTrajectoryFlags::FacingDirection) },
-		{ TEXT("velocityxy"),          int32(EPoseSearchTrajectoryFlags::VelocityXY) },
-		{ TEXT("positionxy"),          int32(EPoseSearchTrajectoryFlags::PositionXY) },
-		{ TEXT("velocitydirectionxy"), int32(EPoseSearchTrajectoryFlags::VelocityDirectionXY) },
-		{ TEXT("facingdirectionxy"),   int32(EPoseSearchTrajectoryFlags::FacingDirectionXY) },
+		{ TEXT("velocity"),            MCPTrajFlagVelocity },
+		{ TEXT("position"),            MCPTrajFlagPosition },
+		{ TEXT("velocitydirection"),   MCPTrajFlagVelocityDirection },
+		{ TEXT("facingdirection"),     MCPTrajFlagFacingDirection },
+		{ TEXT("velocityxy"),          MCPTrajFlagVelocityXY },
+		{ TEXT("positionxy"),          MCPTrajFlagPositionXY },
+		{ TEXT("velocitydirectionxy"), MCPTrajFlagVelocityDirectionXY },
+		{ TEXT("facingdirectionxy"),   MCPTrajFlagFacingDirectionXY },
 	};
 	return Table;
 }
 
+#if !UE_MCP_HAS_5_5_API
+/** Construct one of the PoseSearch channel classes by its script path. On 5.4
+ *  the concrete classes are private to the PoseSearch module, but the UClass is
+ *  registered like any other, so the object is created through it. */
+static UPoseSearchFeatureChannel* MCPNewPoseSearchChannel(UPoseSearchSchema* Schema, const TCHAR* ClassPath)
+{
+	UClass* ChannelClass = FindObject<UClass>(nullptr, ClassPath);
+	if (!ChannelClass) return nullptr;
+	return NewObject<UPoseSearchFeatureChannel>(Schema, ChannelClass, NAME_None, RF_Transactional);
+}
+
+/** Write one reflected property of a channel from JSON. */
+static bool MCPSetChannelProperty(UPoseSearchFeatureChannel* Channel, const TCHAR* PropertyName, const TSharedPtr<FJsonValue>& Value, FString& OutError)
+{
+	return MCPJsonProperty::SetDottedPropertyFromJson(Channel, PropertyName, Value, OutError);
+}
+#endif
+
 // ─── AnimGraph node authoring helpers ─────────────────────────────────────
 
 // Anim graph nodes keep their settings in a private `Node` USTRUCT member. Reach
@@ -228,23 +289,22 @@ TSharedPtr<FJsonValue> FAnimationHandlers::AddPoseSearchSchemaPoseChannel(const
 		return MCPError(TEXT("Missing 'bones' (array of {bone, flags?:[velocity,position,rotation,phase], weight?})"));
 	}
 
-	Schema->Modify();
-	UPoseSearchFeatureChannel_Pose* Channel = NewObject<UPoseSearchFeatureChannel_Pose>(Schema, NAME_None, RF_Transactional);
-	double ChannelWeight = 0.0;
-	if (Params->TryGetNumberField(TEXT("weight"), ChannelWeight)) Channel->Weight = (float)ChannelWeight;
-
+	// Parse first, engine-independently, then write the parsed bones into the
+	// channel the way the running engine allows.
+	struct FParsedBone { FString Name; int32 Flags; float Weight; };
+	TArray<FParsedBone> ParsedBones;
 	TArray<TSharedPtr<FJsonValue>> Added;
 	for (const TSharedPtr<FJsonValue>& V : *Bones)
 	{
 		const TSharedPtr<FJsonObject>* BoneObj = nullptr;
 		FString BoneName;
-		int32 Flags = int32(EPoseSearchBoneFlags::Position);
+		int32 Flags = MCPBoneFlagPosition;
 		float Weight = 1.f;
 		if (V->TryGetObject(BoneObj) && BoneObj && (*BoneObj).IsValid())
 		{
 			if (!(*BoneObj)->TryGetStringField(TEXT("bone"), BoneName))
 				return MCPError(TEXT("Each bone entry needs a 'bone' name"));
-			Flags = ParseFlagArray(*BoneObj, TEXT("flags"), BoneFlagTable(), int32(EPoseSearchBoneFlags::Position));
+			Flags = ParseFlagArray(*BoneObj, TEXT("flags"), BoneFlagTable(), MCPBoneFlagPosition);
 			double W = 0.0;
 			if ((*BoneObj)->TryGetNumberField(TEXT("weight"), W)) Weight = (float)W;
 		}
@@ -253,13 +313,52 @@ TSharedPtr<FJsonValue> FAnimationHandlers::AddPoseSearchSchemaPoseChannel(const
 			return MCPError(TEXT("Each bone entry must be an object or a bone-name string"));
 		}
 
+		ParsedBones.Add({ BoneName, Flags, Weight });
+		Added.Add(MakeShared<FJsonValueString>(BoneName));
+	}
+
+	Schema->Modify();
+	double ChannelWeight = 0.0;
+	const bool bHasChannelWeight = Params->TryGetNumberField(TEXT("weight"), ChannelWeight);
+
+#if UE_MCP_HAS_5_5_API
+	UPoseSearchFeatureChannel_Pose* Channel = NewObject<UPoseSearchFeatureChannel_Pose>(Schema, NAME_None, RF_Transactional);
+	if (bHasChannelWeight) Channel->Weight = (float)ChannelWeight;
+	for (const FParsedBone& Parsed : ParsedBones)
+	{
 		FPoseSearchBone Bone;
-		Bone.Reference.BoneName = FName(*BoneName);
-		Bone.Flags = Flags;
-		Bone.Weight = Weight;
+		Bone.Reference.BoneName = FName(*Parsed.Name);
+		Bone.Flags = Parsed.Flags;
+		Bone.Weight = Parsed.Weight;
 		Channel->SampledBones.Add(Bone);
-		Added.Add(MakeShared<FJsonValueString>(BoneName));
 	}
+#else
+	UPoseSearchFeatureChannel* Channel = MCPNewPoseSearchChannel(Schema, TEXT("/Script/PoseSearch.PoseSearchFeatureChannel_Pose"));
+	if (!Channel) return MCPError(TEXT("PoseSearchFeatureChannel_Pose class is not loaded - is the PoseSearch plugin enabled?"));
+
+	FString PropertyError;
+	if (bHasChannelWeight && !MCPSetChannelProperty(Channel, TEXT("Weight"), MakeShared<FJsonValueNumber>(ChannelWeight), PropertyError))
+	{
+		return MCPError(FString::Printf(TEXT("Could not set channel weight: %s"), *PropertyError));
+	}
+
+	TArray<TSharedPtr<FJsonValue>> BoneStructs;
+	for (const FParsedBone& Parsed : ParsedBones)
+	{
+		TSharedPtr<FJsonObject> Reference = MakeShared<FJsonObject>();
+		Reference->SetStringField(TEXT("BoneName"), Parsed.Name);
+
+		TSharedPtr<FJsonObject> Bone = MakeShared<FJsonObject>();
+		Bone->SetObjectField(TEXT("Reference"), Reference);
+		Bone->SetNumberField(TEXT("Flags"), Parsed.Flags);
+		Bone->SetNumberField(TEXT("Weight"), Parsed.Weight);
+		BoneStructs.Add(MakeShared<FJsonValueObject>(Bone));
+	}
+	if (!MCPSetChannelProperty(Channel, TEXT("SampledBones"), MakeShared<FJsonValueArray>(BoneStructs), PropertyError))
+	{
+		return MCPError(FString::Printf(TEXT("Could not set SampledBones: %s"), *PropertyError));
+	}
+#endif
 
 	Schema->AddChannel(Channel);
 	MCPPoseSearch::Finalize(Schema);
@@ -292,28 +391,62 @@ TSharedPtr<FJsonValue> FAnimationHandlers::AddPoseSearchSchemaTrajectoryChannel(
 		return MCPError(TEXT("Missing 'samples' (array of {offset, flags?:[position,velocity,facingDirection,...], weight?}). Negative offsets are history, positive are prediction."));
 	}
 
-	Schema->Modify();
-	UPoseSearchFeatureChannel_Trajectory* Channel = NewObject<UPoseSearchFeatureChannel_Trajectory>(Schema, NAME_None, RF_Transactional);
-	double ChannelWeight = 0.0;
-	if (Params->TryGetNumberField(TEXT("weight"), ChannelWeight)) Channel->Weight = (float)ChannelWeight;
-
-	int32 Count = 0;
+	struct FParsedSample { float Offset; int32 Flags; float Weight; };
+	TArray<FParsedSample> ParsedSamples;
 	for (const TSharedPtr<FJsonValue>& V : *Samples)
 	{
 		const TSharedPtr<FJsonObject>* SampleObj = nullptr;
 		if (!V->TryGetObject(SampleObj) || !SampleObj || !(*SampleObj).IsValid())
 			return MCPError(TEXT("Each sample must be an object {offset, flags?, weight?}"));
 
-		FPoseSearchTrajectorySample Sample;
 		double Offset = 0.0;
 		(*SampleObj)->TryGetNumberField(TEXT("offset"), Offset);
-		Sample.Offset = (float)Offset;
-		Sample.Flags = ParseFlagArray(*SampleObj, TEXT("flags"), TrajectoryFlagTable(), int32(EPoseSearchTrajectoryFlags::Position));
-		double W = 0.0;
-		if ((*SampleObj)->TryGetNumberField(TEXT("weight"), W)) Sample.Weight = (float)W;
+		const int32 Flags = ParseFlagArray(*SampleObj, TEXT("flags"), TrajectoryFlagTable(), MCPTrajFlagPosition);
+		double W = 1.0;
+		(*SampleObj)->TryGetNumberField(TEXT("weight"), W);
+		ParsedSamples.Add({ (float)Offset, Flags, (float)W });
+	}
+	const int32 Count = ParsedSamples.Num();
+
+	Schema->Modify();
+	double ChannelWeight = 0.0;
+	const bool bHasChannelWeight = Params->TryGetNumberField(TEXT("weight"), ChannelWeight);
+
+#if UE_MCP_HAS_5_5_API
+	UPoseSearchFeatureChannel_Trajectory* Channel = NewObject<UPoseSearchFeatureChannel_Trajectory>(Schema, NAME_None, RF_Transactional);
+	if (bHasChannelWeight) Channel->Weight = (float)ChannelWeight;
+	for (const FParsedSample& Parsed : ParsedSamples)
+	{
+		FPoseSearchTrajectorySample Sample;
+		Sample.Offset = Parsed.Offset;
+		Sample.Flags = Parsed.Flags;
+		Sample.Weight = Parsed.Weight;
 		Channel->Samples.Add(Sample);
-		++Count;
 	}
+#else
+	UPoseSearchFeatureChannel* Channel = MCPNewPoseSearchChannel(Schema, TEXT("/Script/PoseSearch.PoseSearchFeatureChannel_Trajectory"));
+	if (!Channel) return MCPError(TEXT("PoseSearchFeatureChannel_Trajectory class is not loaded - is the PoseSearch plugin enabled?"));
+
+	FString PropertyError;
+	if (bHasChannelWeight && !MCPSetChannelProperty(Channel, TEXT("Weight"), MakeShared<FJsonValueNumber>(ChannelWeight), PropertyError))
+	{
+		return MCPError(FString::Printf(TEXT("Could not set channel weight: %s"), *PropertyError));
+	}
+
+	TArray<TSharedPtr<FJsonValue>> SampleStructs;
+	for (const FParsedSample& Parsed : ParsedSamples)
+	{
+		TSharedPtr<FJsonObject> Sample = MakeShared<FJsonObject>();
+		Sample->SetNumberField(TEXT("Offset"), Parsed.Offset);
+		Sample->SetNumberField(TEXT("Flags"), Parsed.Flags);
+		Sample->SetNumberField(TEXT("Weight"), Parsed.Weight);
+		SampleStructs.Add(MakeShared<FJsonValueObject>(Sample));
+	}
+	if (!MCPSetChannelProperty(Channel, TEXT("Samples"), MakeShared<FJsonValueArray>(SampleStructs), PropertyError))
+	{
+		return MCPError(FString::Printf(TEXT("Could not set Samples: %s"), *PropertyError));
+	}
+#endif
 
 	Schema->AddChannel(Channel);
 	MCPPoseSearch::Finalize(Schema);
@@ -344,7 +477,7 @@ TSharedPtr<FJsonValue> FAnimationHandlers::ReadPoseSearchSchema(const TSharedPtr
 	Res->SetNumberField(TEXT("sampleRate"), Schema->SampleRate);
 
 	TArray<TSharedPtr<FJsonValue>> Skeletons;
-	for (const FPoseSearchRoledSkeleton& Roled : Schema->GetRoledSkeletons())
+	for (const FPoseSearchRoledSkeleton& Roled : MCPPoseSearch::RoledSkeletons(Schema))
 	{
 		TSharedPtr<FJsonObject> S = MakeShared<FJsonObject>();
 		S->SetStringField(TEXT("role"), Roled.Role.ToString());
@@ -526,7 +659,10 @@ TSharedPtr<FJsonValue> FAnimationHandlers::SetPoseSearchDatabaseSettings(const T
 	FString PrevPoseSearchModeName = TEXT("BruteForce");
 	if (PrevPoseSearchMode == EPoseSearchMode::PCAKDTree) PrevPoseSearchModeName = TEXT("PCAKDTree");
 	else if (PrevPoseSearchMode == EPoseSearchMode::VPTree) PrevPoseSearchModeName = TEXT("VPTree");
+#if UE_MCP_HAS_5_5_API
+	// EPoseSearchMode::EventOnly is a later addition to the enum.
 	else if (PrevPoseSearchMode == EPoseSearchMode::EventOnly) PrevPoseSearchModeName = TEXT("EventOnly");
+#endif
 #if WITH_EDITORONLY_DATA
 	const int32 PrevNumberOfPrincipalComponents = Database->NumberOfPrincipalComponents;
 	const FString PrevNormalizationSetPath =
@@ -547,7 +683,9 @@ TSharedPtr<FJsonValue> FAnimationHandlers::SetPoseSearchDatabaseSettings(const T
 		if (Mode.Equals(TEXT("bruteforce"), ESearchCase::IgnoreCase)) Database->PoseSearchMode = EPoseSearchMode::BruteForce;
 		else if (Mode.Equals(TEXT("pcakdtree"), ESearchCase::IgnoreCase)) Database->PoseSearchMode = EPoseSearchMode::PCAKDTree;
 		else if (Mode.Equals(TEXT("vptree"), ESearchCase::IgnoreCase)) Database->PoseSearchMode = EPoseSearchMode::VPTree;
+#if UE_MCP_HAS_5_5_API
 		else if (Mode.Equals(TEXT("eventonly"), ESearchCase::IgnoreCase)) Database->PoseSearchMode = EPoseSearchMode::EventOnly;
+#endif
 	}
 
 #if WITH_EDITORONLY_DATA

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_Sequence.cpp

@@ -1187,8 +1187,40 @@ TSharedPtr<FJsonValue> FAnimationHandlers::ApplyAnimationModifier(const TSharedP
 	bool bRegistered = false;
 	if (!Instance)
 	{
+#if UE_MCP_HAS_5_5_API
 		UAnimationModifiersAssetUserData::AddAnimationModifierOfClass(Seq, ModClass);
 		bRegistered = true;
+#else
+		// 5.4 has no static AddAnimationModifierOfClass, and its member
+		// AddAnimationModifier is protected. That member does exactly one
+		// thing - append to the reflected AnimationModifierInstances array -
+		// so the registration is done through the property system here, and
+		// the sequence keeps the same modifier list the editor tab shows.
+		bRegistered = false;
+		{
+			UAnimationModifiersAssetUserData* Data = Seq->GetAssetUserData<UAnimationModifiersAssetUserData>();
+			if (!Data)
+			{
+				Data = NewObject<UAnimationModifiersAssetUserData>(
+					Seq, UAnimationModifiersAssetUserData::StaticClass(), NAME_None, RF_Transactional);
+				Seq->AddAssetUserData(Data);
+			}
+			FArrayProperty* InstancesProp = FindFProperty<FArrayProperty>(
+				UAnimationModifiersAssetUserData::StaticClass(), TEXT("AnimationModifierInstances"));
+			FObjectProperty* InstanceEntryProp = InstancesProp
+				? CastField<FObjectProperty>(InstancesProp->Inner) : nullptr;
+			if (Data && InstanceEntryProp)
+			{
+				UAnimationModifier* NewModifier = NewObject<UAnimationModifier>(
+					Data, ModClass, NAME_None, RF_Transactional);
+				Data->Modify();
+				FScriptArrayHelper ArrayHelper(InstancesProp, InstancesProp->ContainerPtrToValuePtr<void>(Data));
+				const int32 NewIndex = ArrayHelper.AddValue();
+				InstanceEntryProp->SetObjectPropertyValue(ArrayHelper.GetRawPtr(NewIndex), NewModifier);
+				bRegistered = true;
+			}
+		}
+#endif
 		UserData = Seq->GetAssetUserData<UAnimationModifiersAssetUserData>();
 		if (UserData)
 		{

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_SkeletalLive.cpp

@@ -507,6 +507,18 @@ TSharedPtr<FJsonValue> FAnimationHandlers::PreviewAnimation(const TSharedPtr<FJs
 // or template and disappears when that component is reconstructed.
 TSharedPtr<FJsonValue> FAnimationHandlers::SetLivePostProcessAnimBlueprint(const TSharedPtr<FJsonObject>& Params)
 {
+#if !UE_MCP_HAS_5_5_API
+	// USkeletalMeshComponent::OverridePostProcessAnimBP, its setter, and
+	// GetPostProcessAnimBPClassToBeUsed all arrived in 5.5. On 5.4 the
+	// post-process AnimBP belongs to the SkeletalMesh asset and a component
+	// carries no override to set or clear, so there is no live override to
+	// report on either.
+	auto Result = MakeShared<FJsonObject>();
+	Result->SetBoolField(TEXT("success"), false);
+	Result->SetStringField(TEXT("errorCode"), TEXT("unsupported_engine_version"));
+	Result->SetStringField(TEXT("error"), TEXT("set_live_post_process_anim_blueprint requires Unreal Engine 5.5 or newer, because the per-component post-process AnimBP override does not exist in 5.4. Set the post-process AnimBP on the SkeletalMesh asset instead."));
+	return MCPResult(Result);
+#else
 	FString ActorLabel;
 	if (auto Err = RequireStringAlt(Params, TEXT("actorLabel"), TEXT("actorPath"), ActorLabel)) return Err;
 	const FString ComponentName = OptionalString(Params, TEXT("componentName"));
@@ -612,6 +624,7 @@ TSharedPtr<FJsonValue> FAnimationHandlers::SetLivePostProcessAnimBlueprint(const
 	}
 	MCPSetRollback(Result, TEXT("set_live_post_process_anim_blueprint"), Rollback);
 	return MCPResult(Result);
+#endif
 }
 
 

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AnimationHandlers_Skeleton.cpp

@@ -823,6 +823,62 @@ static TArray<FString> SkeletonBoneNames(const USkeleton* Skeleton)
 	return Out;
 }
 
+// ── Curve metadata flags ─────────────────────────────────────────────────────
+//
+// 5.5 added the named accessors (GetCurveMetaDataMaterial and friends). On 5.4
+// the same two bits live in FCurveMetaData::Type, reached through the mutable
+// GetCurveMetaData, so the flags read and write the same asset data either way.
+
+static bool MCPGetCurveFlagMaterial(const USkeleton* Skeleton, FName CurveName)
+{
+	if (!Skeleton) return false;
+#if UE_MCP_HAS_5_5_API
+	return Skeleton->GetCurveMetaDataMaterial(CurveName);
+#else
+	const FCurveMetaData* MetaData = Skeleton->GetCurveMetaData(CurveName);
+	return MetaData ? MetaData->Type.bMaterial : false;
+#endif
+}
+
+static bool MCPGetCurveFlagMorphTarget(const USkeleton* Skeleton, FName CurveName)
+{
+	if (!Skeleton) return false;
+#if UE_MCP_HAS_5_5_API
+	return Skeleton->GetCurveMetaDataMorphTarget(CurveName);
+#else
+	const FCurveMetaData* MetaData = Skeleton->GetCurveMetaData(CurveName);
+	return MetaData ? MetaData->Type.bMorphtarget : false;
+#endif
+}
+
+static void MCPSetCurveFlagMaterial(USkeleton* Skeleton, FName CurveName, bool bValue)
+{
+	if (!Skeleton) return;
+#if UE_MCP_HAS_5_5_API
+	Skeleton->SetCurveMetaDataMaterial(CurveName, bValue);
+#else
+	if (FCurveMetaData* MetaData = Skeleton->GetCurveMetaData(CurveName))
+	{
+		Skeleton->Modify();
+		MetaData->Type.bMaterial = bValue;
+	}
+#endif
+}
+
+static void MCPSetCurveFlagMorphTarget(USkeleton* Skeleton, FName CurveName, bool bValue)
+{
+	if (!Skeleton) return;
+#if UE_MCP_HAS_5_5_API
+	Skeleton->SetCurveMetaDataMorphTarget(CurveName, bValue);
+#else
+	if (FCurveMetaData* MetaData = Skeleton->GetCurveMetaData(CurveName))
+	{
+		Skeleton->Modify();
+		MetaData->Type.bMorphtarget = bValue;
+	}
+#endif
+}
+
 } // namespace UE_MCP_SkeletonEdit
 
 // ═════════════════════════════════════════════════════════════════════════════
@@ -2572,7 +2628,12 @@ TSharedPtr<FJsonValue> FAnimationHandlers::EditCurveMetadata(const TSharedPtr<FJ
 			Row->SetStringField(TEXT("curve"), Curve);
 			// Returns false when an entry already existed, which is the
 			// idempotent case rather than a failure.
-			const bool bNew = Skeleton->AddCurveMetaData(FName(*Curve), false);
+#if UE_MCP_HAS_5_5_API
+			const bool bNew = Skeleton->AddCurveMetaData(FName(*Curve), /*bTransact*/ false);
+#else
+			// 5.4 has no bTransact parameter; the call transacts either way.
+			const bool bNew = Skeleton->AddCurveMetaData(FName(*Curve));
+#endif
 			Row->SetBoolField(TEXT("created"), bNew);
 			Row->SetBoolField(TEXT("existed"), !bNew);
 			bNew ? ++Added : ++AlreadyPresent;
@@ -2587,23 +2648,23 @@ TSharedPtr<FJsonValue> FAnimationHandlers::EditCurveMetadata(const TSharedPtr<FJ
 			bool bChanged = false;
 			if (Flag.bMaterial.IsSet())
 			{
-				const bool Prior = Skeleton->GetCurveMetaDataMaterial(FName(*Flag.Curve));
+				const bool Prior = MCPGetCurveFlagMaterial(Skeleton, FName(*Flag.Curve));
 				Row->SetBoolField(TEXT("priorMaterial"), Prior);
 				Row->SetBoolField(TEXT("material"), Flag.bMaterial.GetValue());
 				if (Prior != Flag.bMaterial.GetValue())
 				{
-					Skeleton->SetCurveMetaDataMaterial(FName(*Flag.Curve), Flag.bMaterial.GetValue());
+					MCPSetCurveFlagMaterial(Skeleton, FName(*Flag.Curve), Flag.bMaterial.GetValue());
 					bChanged = true;
 				}
 			}
 			if (Flag.bMorphTarget.IsSet())
 			{
-				const bool Prior = Skeleton->GetCurveMetaDataMorphTarget(FName(*Flag.Curve));
+				const bool Prior = MCPGetCurveFlagMorphTarget(Skeleton, FName(*Flag.Curve));
 				Row->SetBoolField(TEXT("priorMorphTarget"), Prior);
 				Row->SetBoolField(TEXT("morphTarget"), Flag.bMorphTarget.GetValue());
 				if (Prior != Flag.bMorphTarget.GetValue())
 				{
-					Skeleton->SetCurveMetaDataMorphTarget(FName(*Flag.Curve), Flag.bMorphTarget.GetValue());
+					MCPSetCurveFlagMorphTarget(Skeleton, FName(*Flag.Curve), Flag.bMorphTarget.GetValue());
 					bChanged = true;
 				}
 			}