flockbay 0.10.15 → 0.10.16

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/Commands/UnrealMCPEditorCommands.cpp

@@ -1,6 +1,7 @@
 #include "Commands/UnrealMCPEditorCommands.h"
 #include "Commands/UnrealMCPCommonUtils.h"
 #include "Editor.h"
+#include "Editor/EditorEngine.h"
 #include "EditorViewportClient.h"
 #include "LevelEditorViewport.h"
 #include "IAssetViewport.h"
@@ -15,11 +16,17 @@
 #include "Kismet/GameplayStatics.h"
 #include "Engine/StaticMeshActor.h"
 #include "Engine/StaticMesh.h"
+#include "Engine/Texture2D.h"
+#include "Engine/SkeletalMesh.h"
 #include "Engine/DirectionalLight.h"
 #include "Engine/PointLight.h"
 #include "Engine/SpotLight.h"
 #include "Camera/CameraActor.h"
+#include "Landscape.h"
+#include "LandscapeImportHelper.h"
 #include "Components/StaticMeshComponent.h"
+#include "Materials/MaterialInterface.h"
+#include "Sound/SoundWave.h"
 #include "EditorSubsystem.h"
 #include "Subsystems/EditorActorSubsystem.h"
 #include "Engine/Blueprint.h"
@@ -32,6 +39,16 @@
 #include "PlayInEditorDataTypes.h"
 #include "Settings/LevelEditorPlaySettings.h"
 #include "Framework/Application/SlateApplication.h"
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "UObject/SoftObjectPath.h"
+#include "UObject/Package.h"
+#include "FileHelpers.h"
+#include "MessageLogModule.h"
+#include "IMessageLogListing.h"
+#include "Engine/World.h"
+#include "Engine/EngineTypes.h"
+#include "GameFramework/PlayerController.h"
+#include "Camera/PlayerCameraManager.h"
 
 FUnrealMCPEditorCommands::FUnrealMCPEditorCommands()
 {
@@ -56,6 +73,10 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleCommand(const FString& C
         }
         return HandleSpawnActor(Params);
     }
+    else if (CommandType == TEXT("create_landscape"))
+    {
+        return HandleCreateLandscape(Params);
+    }
     else if (CommandType == TEXT("delete_actor"))
     {
         return HandleDeleteActor(Params);
@@ -86,6 +107,10 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleCommand(const FString& C
     {
         return HandleTakeScreenshot(Params);
     }
+    else if (CommandType == TEXT("save_all"))
+    {
+        return HandleSaveAll(Params);
+    }
     else if (CommandType == TEXT("get_play_in_editor_status"))
     {
         return HandleGetPlayInEditorStatus(Params);
@@ -102,6 +127,50 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleCommand(const FString& C
     {
         return HandleStopPlayInEditor(Params);
     }
+    else if (CommandType == TEXT("search_assets"))
+    {
+        return HandleSearchAssets(Params);
+    }
+    else if (CommandType == TEXT("get_asset_info"))
+    {
+        return HandleGetAssetInfo(Params);
+    }
+    else if (CommandType == TEXT("list_asset_packs"))
+    {
+        return HandleListAssetPacks(Params);
+    }
+    else if (CommandType == TEXT("place_asset"))
+    {
+        return HandlePlaceAsset(Params);
+    }
+    else if (CommandType == TEXT("map_check"))
+    {
+        return HandleMapCheck(Params);
+    }
+    else if (CommandType == TEXT("get_editor_context"))
+    {
+        return HandleGetEditorContext(Params);
+    }
+    else if (CommandType == TEXT("get_player_context"))
+    {
+        return HandleGetPlayerContext(Params);
+    }
+    else if (CommandType == TEXT("raycast_from_camera"))
+    {
+        return HandleRaycastFromCamera(Params);
+    }
+    else if (CommandType == TEXT("raycast_down"))
+    {
+        return HandleRaycastDown(Params);
+    }
+    else if (CommandType == TEXT("get_actor_transform"))
+    {
+        return HandleGetActorTransform(Params);
+    }
+    else if (CommandType == TEXT("get_actor_bounds"))
+    {
+        return HandleGetActorBounds(Params);
+    }
     
     return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Unknown editor command: %s"), *CommandType));
 }
@@ -134,142 +203,1224 @@ static bool IsSafeToModifyEditorWorld(FString& OutError)
         return false;
     }
 
-    return true;
-}
+    return true;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSaveAll(const TSharedPtr<FJsonObject>& Params)
+{
+    FString Err;
+    if (!IsSafeToModifyEditorWorld(Err))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+    }
+
+    TArray<UPackage*> DirtyBefore;
+    FEditorFileUtils::GetDirtyPackages(DirtyBefore, /*bIncludeMapPackages=*/true, /*bIncludeContentPackages=*/true);
+
+    TSet<FString> DirtyBeforeNames;
+    for (UPackage* Pkg : DirtyBefore)
+    {
+        if (!Pkg) continue;
+        DirtyBeforeNames.Add(Pkg->GetName());
+    }
+
+    const int32 DirtyBeforeCount = DirtyBeforeNames.Num();
+
+    // Save without prompting; fail-hard if anything remains dirty.
+    const bool bSaveOk = FEditorFileUtils::SaveDirtyPackages(
+        /*bPromptUserToSave=*/false,
+        /*bSaveMapPackages=*/true,
+        /*bSaveContentPackages=*/true,
+        /*bFastSave=*/false
+    );
+
+    TArray<UPackage*> DirtyAfter;
+    FEditorFileUtils::GetDirtyPackages(DirtyAfter, /*bIncludeMapPackages=*/true, /*bIncludeContentPackages=*/true);
+
+    TSet<FString> DirtyAfterNames;
+    for (UPackage* Pkg : DirtyAfter)
+    {
+        if (!Pkg) continue;
+        DirtyAfterNames.Add(Pkg->GetName());
+    }
+
+    TArray<TSharedPtr<FJsonValue>> Attempted;
+    for (const FString& Name : DirtyBeforeNames)
+    {
+        Attempted.Add(MakeShareable(new FJsonValueString(Name)));
+    }
+
+    TArray<TSharedPtr<FJsonValue>> StillDirty;
+    for (const FString& Name : DirtyAfterNames)
+    {
+        StillDirty.Add(MakeShareable(new FJsonValueString(Name)));
+    }
+
+    TArray<TSharedPtr<FJsonValue>> Saved;
+    for (const FString& Name : DirtyBeforeNames)
+    {
+        if (!DirtyAfterNames.Contains(Name))
+        {
+            Saved.Add(MakeShareable(new FJsonValueString(Name)));
+        }
+    }
+
+    if (DirtyBeforeCount == 0)
+    {
+        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+        ResultObj->SetBoolField(TEXT("success"), true);
+        ResultObj->SetNumberField(TEXT("dirtyBefore"), DirtyBeforeCount);
+        ResultObj->SetNumberField(TEXT("dirtyAfter"), DirtyAfterNames.Num());
+        ResultObj->SetArrayField(TEXT("attemptedPackages"), Attempted);
+        ResultObj->SetArrayField(TEXT("savedPackages"), Saved);
+        ResultObj->SetArrayField(TEXT("stillDirtyPackages"), StillDirty);
+        ResultObj->SetStringField(TEXT("message"), TEXT("No unsaved changes were detected."));
+        return ResultObj;
+    }
+
+    if (DirtyAfterNames.Num() > 0)
+    {
+        TSharedPtr<FJsonObject> Details = MakeShared<FJsonObject>();
+        Details->SetBoolField(TEXT("saveOk"), bSaveOk);
+        Details->SetNumberField(TEXT("dirtyBefore"), DirtyBeforeCount);
+        Details->SetNumberField(TEXT("dirtyAfter"), DirtyAfterNames.Num());
+        Details->SetArrayField(TEXT("attemptedPackages"), Attempted);
+        Details->SetArrayField(TEXT("savedPackages"), Saved);
+        Details->SetArrayField(TEXT("stillDirtyPackages"), StillDirty);
+
+        TSharedPtr<FJsonObject> ErrObj = FUnrealMCPCommonUtils::CreateErrorResponse(
+            TEXT("Some packages are still dirty after save_all. They may require manual Save As, source control checkout, or have save errors. Resolve in-editor and retry save_all."),
+        );
+        ErrObj->SetObjectField(TEXT("details"), Details);
+        return ErrObj;
+    }
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("success"), true);
+    ResultObj->SetNumberField(TEXT("dirtyBefore"), DirtyBeforeCount);
+    ResultObj->SetNumberField(TEXT("dirtyAfter"), DirtyAfterNames.Num());
+    ResultObj->SetArrayField(TEXT("attemptedPackages"), Attempted);
+    ResultObj->SetArrayField(TEXT("savedPackages"), Saved);
+    ResultObj->SetArrayField(TEXT("stillDirtyPackages"), StillDirty);
+    ResultObj->SetStringField(TEXT("message"), TEXT("Saved all dirty packages."));
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetPlayInEditorStatus(const TSharedPtr<FJsonObject>& Params)
+{
+    return CreatePlayStatusResponse();
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditor(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionInProgress())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+    }
+
+    // Use the active editor viewport, matching how the LevelEditor subsystem triggers PIE.
+    FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
+    if (!LevelEditorModule)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("LevelEditor module not available."));
+    }
+
+    TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
+    if (!ActiveViewport.IsValid())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No active level viewport. Click the viewport and retry."));
+    }
+
+    FRequestPlaySessionParams SessionParams;
+    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
+    SessionParams.DestinationSlateViewport = ActiveViewport;
+
+    GEditor->RequestPlaySession(SessionParams);
+    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("requested"), true);
+    ResultObj->SetBoolField(TEXT("queued"), bQueued);
+    ResultObj->SetBoolField(TEXT("started"), bQueued);
+    ResultObj->SetStringField(TEXT("mode"), TEXT("pie"));
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditorWindowed(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionInProgress())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+    }
+
+    // Match the editor's built-in "New Editor Window (PIE)" behavior by setting the play mode type and
+    // not specifying a DestinationSlateViewport.
+    ULevelEditorPlaySettings* PlaySettings = GetMutableDefault<ULevelEditorPlaySettings>();
+    if (PlaySettings)
+    {
+        PlaySettings->LastExecutedPlayModeType = EPlayModeType::PlayMode_InEditorFloating;
+
+        if (FProperty* Prop = ULevelEditorPlaySettings::StaticClass()->FindPropertyByName(
+                GET_MEMBER_NAME_CHECKED(ULevelEditorPlaySettings, LastExecutedPlayModeType)))
+        {
+            FPropertyChangedEvent PropChangeEvent(Prop);
+            PlaySettings->PostEditChangeProperty(PropChangeEvent);
+        }
+
+        PlaySettings->SaveConfig();
+    }
+
+    const bool bAtPlayerStart =
+        PlaySettings && PlaySettings->LastExecutedPlayModeLocation == EPlayModeLocations::PlayLocation_DefaultPlayerStart;
+
+    FRequestPlaySessionParams SessionParams;
+    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
+
+    // If the user is playing from current camera location, use the active viewport camera as the start transform.
+    if (!bAtPlayerStart)
+    {
+        FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
+        if (LevelEditorModule)
+        {
+            TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
+            if (ActiveViewport.IsValid() && FSlateApplication::IsInitialized() &&
+                FSlateApplication::Get().FindWidgetWindow(ActiveViewport->AsWidget()).IsValid())
+            {
+                SessionParams.StartLocation = ActiveViewport->GetAssetViewportClient().GetViewLocation();
+                SessionParams.StartRotation = ActiveViewport->GetAssetViewportClient().GetViewRotation();
+            }
+        }
+    }
+
+    GEditor->RequestPlaySession(SessionParams);
+    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("requested"), true);
+    ResultObj->SetBoolField(TEXT("queued"), bQueued);
+    ResultObj->SetBoolField(TEXT("started"), bQueued);
+    ResultObj->SetStringField(TEXT("mode"), TEXT("pie_new_window"));
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleStopPlayInEditor(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionRequestQueued() && !GEditor->IsPlayingSessionInEditor())
+    {
+        GEditor->CancelRequestPlaySession();
+        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+        ResultObj->SetBoolField(TEXT("stopped"), true);
+        ResultObj->SetBoolField(TEXT("canceled"), true);
+        return ResultObj;
+    }
+
+    if (!GEditor->IsPlayingSessionInEditor())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No play session is running."));
+    }
+
+    GEditor->RequestEndPlayMap();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("stopped"), true);
+    return ResultObj;
+}
+
+static FString NormalizeContentRoot(const FString& Root)
+{
+    FString Out = Root.TrimStartAndEnd();
+    if (Out.IsEmpty())
+    {
+        return TEXT("/Game/");
+    }
+    if (!Out.StartsWith(TEXT("/")))
+    {
+        Out = TEXT("/") + Out;
+    }
+    if (!Out.EndsWith(TEXT("/")))
+    {
+        Out += TEXT("/");
+    }
+    return Out;
+}
+
+static bool TryResolveAssetClassFilter(const TSharedPtr<FJsonObject>& Params, FARFilter& Filter, FString& OutError)
+{
+    if (!Params.IsValid() || !Params->HasField(TEXT("class")))
+    {
+        return true;
+    }
+
+    TArray<FString> ClassNames;
+
+    FString Single;
+    if (Params->TryGetStringField(TEXT("class"), Single))
+    {
+        Single = Single.TrimStartAndEnd();
+        if (!Single.IsEmpty())
+        {
+            ClassNames.Add(Single);
+        }
+    }
+    else
+    {
+        const TArray<TSharedPtr<FJsonValue>>* Arr = nullptr;
+        if (Params->TryGetArrayField(TEXT("class"), Arr) && Arr)
+        {
+            for (const TSharedPtr<FJsonValue>& V : *Arr)
+            {
+                if (!V.IsValid() || V->Type != EJson::String) continue;
+                FString S = V->AsString().TrimStartAndEnd();
+                if (!S.IsEmpty()) ClassNames.Add(S);
+            }
+        }
+    }
+
+    for (const FString& ClassNameRaw : ClassNames)
+    {
+        const FString ClassName = ClassNameRaw.TrimStartAndEnd();
+        if (ClassName.IsEmpty()) continue;
+
+        UClass* Class = nullptr;
+
+        if (ClassName.Equals(TEXT("StaticMesh"), ESearchCase::IgnoreCase) || ClassName.Equals(TEXT("UStaticMesh"), ESearchCase::IgnoreCase))
+        {
+            Class = UStaticMesh::StaticClass();
+        }
+        else if (ClassName.Equals(TEXT("Material"), ESearchCase::IgnoreCase) || ClassName.Equals(TEXT("MaterialInterface"), ESearchCase::IgnoreCase))
+        {
+            Class = UMaterialInterface::StaticClass();
+        }
+        else if (ClassName.Equals(TEXT("Texture2D"), ESearchCase::IgnoreCase))
+        {
+            Class = UTexture2D::StaticClass();
+        }
+        else if (ClassName.Equals(TEXT("Blueprint"), ESearchCase::IgnoreCase) || ClassName.Equals(TEXT("UBlueprint"), ESearchCase::IgnoreCase))
+        {
+            Class = UBlueprint::StaticClass();
+        }
+        else if (ClassName.Equals(TEXT("SkeletalMesh"), ESearchCase::IgnoreCase))
+        {
+            Class = USkeletalMesh::StaticClass();
+        }
+        else if (ClassName.Equals(TEXT("SoundWave"), ESearchCase::IgnoreCase))
+        {
+            Class = USoundWave::StaticClass();
+        }
+        else
+        {
+            Class = FindObject<UClass>(ANY_PACKAGE, *ClassName);
+            if (!Class && !ClassName.StartsWith(TEXT("U")))
+            {
+                Class = FindObject<UClass>(ANY_PACKAGE, *(TEXT("U") + ClassName));
+            }
+        }
+
+        if (!Class)
+        {
+            OutError = FString::Printf(TEXT("Unknown asset class filter: %s"), *ClassNameRaw);
+            return false;
+        }
+
+        Filter.ClassPaths.Add(Class->GetClassPathName());
+    }
+
+    return true;
+}
+
+static int32 ScoreAssetMatch(const FString& Query, const FAssetData& Asset)
+{
+    if (Query.IsEmpty()) return 0;
+
+    const FString Name = Asset.AssetName.ToString();
+    const FString Path = Asset.GetObjectPathString();
+
+    if (Name.Equals(Query, ESearchCase::IgnoreCase)) return 0;
+    if (Name.StartsWith(Query, ESearchCase::IgnoreCase)) return 1;
+    if (Path.EndsWith(Query, ESearchCase::IgnoreCase)) return 2;
+    if (Name.Contains(Query, ESearchCase::IgnoreCase)) return 3;
+    if (Path.Contains(Query, ESearchCase::IgnoreCase)) return 4;
+    return 100;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSearchAssets(const TSharedPtr<FJsonObject>& Params)
+{
+    FString Root = TEXT("/Game/");
+    Params->TryGetStringField(TEXT("root"), Root);
+    Root = NormalizeContentRoot(Root);
+
+    FString Query;
+    Params->TryGetStringField(TEXT("query"), Query);
+    Query = Query.TrimStartAndEnd();
+
+    int32 Limit = 25;
+    if (Params->HasField(TEXT("limit")))
+    {
+        Limit = (int32)Params->GetNumberField(TEXT("limit"));
+    }
+    Limit = FMath::Clamp(Limit, 1, 200);
+
+    FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+    IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+    FARFilter Filter;
+    Filter.PackagePaths.Add(*Root);
+    Filter.bRecursivePaths = true;
+
+    FString ClassErr;
+    if (!TryResolveAssetClassFilter(Params, Filter, ClassErr))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(ClassErr);
+    }
+
+    TArray<FAssetData> Assets;
+    AssetRegistry.GetAssets(Filter, Assets);
+
+    if (!Query.IsEmpty())
+    {
+        Assets.RemoveAll([&Query](const FAssetData& Asset) {
+            const FString Name = Asset.AssetName.ToString();
+            const FString Path = Asset.GetObjectPathString();
+            return !(Name.Contains(Query, ESearchCase::IgnoreCase) || Path.Contains(Query, ESearchCase::IgnoreCase));
+        });
+
+        Assets.Sort([&Query](const FAssetData& A, const FAssetData& B) {
+            const int32 SA = ScoreAssetMatch(Query, A);
+            const int32 SB = ScoreAssetMatch(Query, B);
+            if (SA != SB) return SA < SB;
+            return A.AssetName.LexicalLess(B.AssetName);
+        });
+    }
+    else
+    {
+        Assets.Sort([](const FAssetData& A, const FAssetData& B) {
+            return A.AssetName.LexicalLess(B.AssetName);
+        });
+    }
+
+    const int32 Total = Assets.Num();
+    if (Assets.Num() > Limit)
+    {
+        Assets.SetNum(Limit);
+    }
+
+    TArray<TSharedPtr<FJsonValue>> OutAssets;
+    OutAssets.Reserve(Assets.Num());
+    for (const FAssetData& Asset : Assets)
+    {
+        TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+        Obj->SetStringField(TEXT("name"), Asset.AssetName.ToString());
+        Obj->SetStringField(TEXT("objectPath"), Asset.GetObjectPathString());
+        Obj->SetStringField(TEXT("packagePath"), Asset.PackagePath.ToString());
+        Obj->SetStringField(TEXT("class"), Asset.AssetClassPath.ToString());
+        OutAssets.Add(MakeShared<FJsonValueObject>(Obj));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("root"), Root);
+    Result->SetStringField(TEXT("query"), Query);
+    Result->SetNumberField(TEXT("count"), OutAssets.Num());
+    Result->SetNumberField(TEXT("totalMatches"), Total);
+    Result->SetArrayField(TEXT("assets"), OutAssets);
+    return Result;
+}
+
+static FString InferPlacementKindFromAssetClassPath(const FString& ClassPath)
+{
+    if (ClassPath.Contains(TEXT("StaticMesh"), ESearchCase::IgnoreCase)) return TEXT("static_mesh");
+    if (ClassPath.Contains(TEXT("Blueprint"), ESearchCase::IgnoreCase)) return TEXT("blueprint");
+    if (ClassPath.Contains(TEXT("Material"), ESearchCase::IgnoreCase)) return TEXT("material");
+    if (ClassPath.Contains(TEXT("Texture"), ESearchCase::IgnoreCase)) return TEXT("texture");
+    return TEXT("unknown");
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetAssetInfo(const TSharedPtr<FJsonObject>& Params)
+{
+    FString ObjectPath;
+    if (!Params->TryGetStringField(TEXT("objectPath"), ObjectPath) && !Params->TryGetStringField(TEXT("object_path"), ObjectPath))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'objectPath' parameter"));
+    }
+    ObjectPath = ObjectPath.TrimStartAndEnd();
+    if (ObjectPath.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("objectPath is empty"));
+    }
+
+    FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+    IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+    const FAssetData Asset = AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(ObjectPath));
+    if (!Asset.IsValid())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Asset not found: %s"), *ObjectPath));
+    }
+
+    const FString ClassPath = Asset.AssetClassPath.ToString();
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("name"), Asset.AssetName.ToString());
+    Result->SetStringField(TEXT("objectPath"), Asset.GetObjectPathString());
+    Result->SetStringField(TEXT("packageName"), Asset.PackageName.ToString());
+    Result->SetStringField(TEXT("packagePath"), Asset.PackagePath.ToString());
+    Result->SetStringField(TEXT("class"), ClassPath);
+    Result->SetStringField(TEXT("placementKind"), InferPlacementKindFromAssetClassPath(ClassPath));
+
+    if (Params->HasField(TEXT("includeDependencies")) && Params->GetBoolField(TEXT("includeDependencies")))
+    {
+        TArray<FName> Deps;
+        AssetRegistry.GetDependencies(Asset.PackageName, Deps);
+        TArray<TSharedPtr<FJsonValue>> DepArr;
+        DepArr.Reserve(Deps.Num());
+        for (const FName& Dep : Deps)
+        {
+            DepArr.Add(MakeShared<FJsonValueString>(Dep.ToString()));
+        }
+        Result->SetArrayField(TEXT("dependencies"), DepArr);
+    }
+
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleListAssetPacks(const TSharedPtr<FJsonObject>& Params)
+{
+    int32 Limit = 200;
+    if (Params->HasField(TEXT("limit")))
+    {
+        Limit = (int32)Params->GetNumberField(TEXT("limit"));
+    }
+    Limit = FMath::Clamp(Limit, 1, 500);
+
+    FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+    IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+    TArray<FString> SubPaths;
+    AssetRegistry.GetSubPaths(TEXT("/Game"), SubPaths, false);
+    SubPaths.Sort();
+
+    TArray<TSharedPtr<FJsonValue>> Packs;
+    for (const FString& Path : SubPaths)
+    {
+        if (Packs.Num() >= Limit) break;
+        if (Path.StartsWith(TEXT("/Game/__External"), ESearchCase::IgnoreCase)) continue;
+        if (Path.StartsWith(TEXT("/Game/Developers"), ESearchCase::IgnoreCase)) continue;
+
+        FString Name = Path;
+        int32 SlashIndex;
+        if (Name.FindLastChar(TEXT('/'), SlashIndex))
+        {
+            Name = Name.Mid(SlashIndex + 1);
+        }
+
+        TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+        Obj->SetStringField(TEXT("name"), Name);
+        Obj->SetStringField(TEXT("path"), Path + TEXT("/"));
+        Packs.Add(MakeShared<FJsonValueObject>(Obj));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetNumberField(TEXT("count"), Packs.Num());
+    Result->SetArrayField(TEXT("packs"), Packs);
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlaceAsset(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    FString ObjectPath;
+    if (!Params->TryGetStringField(TEXT("objectPath"), ObjectPath) && !Params->TryGetStringField(TEXT("object_path"), ObjectPath))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'objectPath' parameter"));
+    }
+    ObjectPath = ObjectPath.TrimStartAndEnd();
+    if (ObjectPath.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("objectPath is empty"));
+    }
+
+    FVector Location(0.0f, 0.0f, 0.0f);
+    FRotator Rotation(0.0f, 0.0f, 0.0f);
+    FVector Scale(1.0f, 1.0f, 1.0f);
+
+    if (Params->HasField(TEXT("location")))
+    {
+        Location = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location"));
+    }
+    if (Params->HasField(TEXT("rotation")))
+    {
+        Rotation = FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("rotation"));
+    }
+    if (Params->HasField(TEXT("scale")))
+    {
+        Scale = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("scale"));
+    }
+
+    UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    FString AssetClassPath;
+    FString AssetName;
+    {
+        FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+        IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+        const FAssetData Asset = AssetRegistry.GetAssetByObjectPath(FSoftObjectPath(ObjectPath));
+        if (Asset.IsValid())
+        {
+            AssetClassPath = Asset.AssetClassPath.ToString();
+            AssetName = Asset.AssetName.ToString();
+        }
+    }
+
+    FString RequestedName;
+    Params->TryGetStringField(TEXT("name"), RequestedName);
+    RequestedName = RequestedName.TrimStartAndEnd();
+    if (RequestedName.IsEmpty())
+    {
+        RequestedName = !AssetName.IsEmpty() ? AssetName : TEXT("PlacedAsset");
+    }
+
+    AActor* NewActor = nullptr;
+    FString PlacementKind = !AssetClassPath.IsEmpty() ? InferPlacementKindFromAssetClassPath(AssetClassPath) : TEXT("unknown");
+
+    UObject* AssetObj = LoadObject<UObject>(nullptr, *ObjectPath);
+    if (!AssetObj && !ObjectPath.Contains(TEXT("'")))
+    {
+        AssetObj = LoadObject<UObject>(nullptr, *FString::Printf(TEXT("StaticMesh'%s'"), *ObjectPath));
+        if (!AssetObj)
+        {
+            AssetObj = LoadObject<UObject>(nullptr, *FString::Printf(TEXT("Blueprint'%s'"), *ObjectPath));
+        }
+    }
+
+    if (!AssetObj)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Failed to load asset: %s"), *ObjectPath));
+    }
+
+    FActorSpawnParameters SpawnParams;
+    SpawnParams.Name = MakeUniqueObjectName(World, AActor::StaticClass(), FName(*RequestedName));
+
+    if (UStaticMesh* StaticMesh = Cast<UStaticMesh>(AssetObj))
+    {
+        PlacementKind = TEXT("static_mesh");
+        AStaticMeshActor* StaticMeshActor = World->SpawnActor<AStaticMeshActor>(AStaticMeshActor::StaticClass(), Location, Rotation, SpawnParams);
+        if (!StaticMeshActor || !StaticMeshActor->GetStaticMeshComponent())
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn StaticMeshActor"));
+        }
+
+        StaticMeshActor->GetStaticMeshComponent()->SetStaticMesh(StaticMesh);
+        StaticMeshActor->GetStaticMeshComponent()->MarkRenderStateDirty();
+        NewActor = StaticMeshActor;
+    }
+    else if (UBlueprint* Blueprint = Cast<UBlueprint>(AssetObj))
+    {
+        PlacementKind = TEXT("blueprint");
+        if (!Blueprint->GeneratedClass)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Blueprint has no GeneratedClass (compile it and retry)."));
+        }
+        const FTransform SpawnTransform(FQuat(Rotation), Location, Scale);
+        NewActor = World->SpawnActor<AActor>(Blueprint->GeneratedClass, SpawnTransform, SpawnParams);
+    }
+    else if (UBlueprintGeneratedClass* GeneratedClass = Cast<UBlueprintGeneratedClass>(AssetObj))
+    {
+        PlacementKind = TEXT("blueprint");
+        const FTransform SpawnTransform(FQuat(Rotation), Location, Scale);
+        NewActor = World->SpawnActor<AActor>(GeneratedClass, SpawnTransform, SpawnParams);
+    }
+    else if (UClass* Class = Cast<UClass>(AssetObj))
+    {
+        if (!Class->IsChildOf(AActor::StaticClass()))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Loaded class is not an Actor class: %s"), *Class->GetName()));
+        }
+        PlacementKind = TEXT("blueprint");
+        const FTransform SpawnTransform(FQuat(Rotation), Location, Scale);
+        NewActor = World->SpawnActor<AActor>(Class, SpawnTransform, SpawnParams);
+    }
+    else
+    {
+        const FString ClassName = AssetObj->GetClass() ? AssetObj->GetClass()->GetName() : TEXT("UnknownClass");
+        return FUnrealMCPCommonUtils::CreateErrorResponse(
+            FString::Printf(TEXT("Asset is not placeable (class: %s). Placeable: StaticMesh, Blueprint. Asset: %s"), *ClassName, *ObjectPath));
+    }
+
+    if (!NewActor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn actor for asset."));
+    }
+
+    NewActor->SetActorScale3D(Scale);
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("placementKind"), PlacementKind);
+    Result->SetStringField(TEXT("requestedObjectPath"), ObjectPath);
+    Result->SetStringField(TEXT("spawnedName"), NewActor->GetName());
+    Result->SetObjectField(TEXT("actor"), FUnrealMCPCommonUtils::ActorToJsonObject(NewActor, true));
+    return Result;
+}
+
+static FString MessageSeverityToString(EMessageSeverity::Type Severity)
+{
+    switch (Severity)
+    {
+        case EMessageSeverity::CriticalError:
+        case EMessageSeverity::Error:
+            return TEXT("error");
+        case EMessageSeverity::Warning:
+        case EMessageSeverity::PerformanceWarning:
+            return TEXT("warning");
+        case EMessageSeverity::Info:
+            return TEXT("info");
+        default:
+            return TEXT("info");
+    }
+}
+
+static TArray<TSharedPtr<FJsonValue>> VectorToJsonArray(const FVector& V)
+{
+    TArray<TSharedPtr<FJsonValue>> Arr;
+    Arr.Add(MakeShared<FJsonValueNumber>(V.X));
+    Arr.Add(MakeShared<FJsonValueNumber>(V.Y));
+    Arr.Add(MakeShared<FJsonValueNumber>(V.Z));
+    return Arr;
+}
+
+static TArray<TSharedPtr<FJsonValue>> RotatorToJsonArray(const FRotator& R)
+{
+    TArray<TSharedPtr<FJsonValue>> Arr;
+    Arr.Add(MakeShared<FJsonValueNumber>(R.Pitch));
+    Arr.Add(MakeShared<FJsonValueNumber>(R.Yaw));
+    Arr.Add(MakeShared<FJsonValueNumber>(R.Roll));
+    return Arr;
+}
+
+static AActor* FindActorByNameOrLabel(UWorld* World, const FString& NameOrLabel)
+{
+    if (!World) return nullptr;
+    if (NameOrLabel.IsEmpty()) return nullptr;
+
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(World, AActor::StaticClass(), AllActors);
+    for (AActor* Actor : AllActors)
+    {
+        if (!Actor) continue;
+        if (Actor->GetName().Equals(NameOrLabel, ESearchCase::CaseSensitive) ||
+            Actor->GetName().Equals(NameOrLabel, ESearchCase::IgnoreCase))
+        {
+            return Actor;
+        }
+#if WITH_EDITOR
+        if (Actor->GetActorLabel().Equals(NameOrLabel, ESearchCase::IgnoreCase))
+        {
+            return Actor;
+        }
+#endif
+    }
+
+    return nullptr;
+}
+
+static TSharedPtr<FJsonObject> RaycastInWorld(UWorld* World, const FVector& Start, const FVector& Dir, float MaxDistance, const TArray<FString>& IgnoreActorNames)
+{
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No world available for raycast."));
+    }
+
+    const FVector Direction = Dir.GetSafeNormal();
+    if (Direction.IsNearlyZero())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Raycast direction is zero."));
+    }
+
+    MaxDistance = FMath::Clamp(MaxDistance, 1.0f, 1.0e7f);
+    const FVector End = Start + Direction * MaxDistance;
+
+    FCollisionQueryParams QueryParams(SCENE_QUERY_STAT(UnrealMCP_Raycast), true);
+    QueryParams.bReturnPhysicalMaterial = false;
+
+    for (const FString& Name : IgnoreActorNames)
+    {
+        if (AActor* Actor = FindActorByNameOrLabel(World, Name))
+        {
+            QueryParams.AddIgnoredActor(Actor);
+        }
+    }
+
+    FHitResult Hit;
+    const bool bHit = World->LineTraceSingleByChannel(Hit, Start, End, ECC_Visibility, QueryParams);
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetBoolField(TEXT("hit"), bHit);
+    Result->SetArrayField(TEXT("start"), VectorToJsonArray(Start));
+    Result->SetArrayField(TEXT("end"), VectorToJsonArray(End));
+    Result->SetNumberField(TEXT("maxDistance"), MaxDistance);
+
+    if (!bHit)
+    {
+        return Result;
+    }
+
+    Result->SetArrayField(TEXT("location"), VectorToJsonArray(Hit.ImpactPoint));
+    Result->SetArrayField(TEXT("normal"), VectorToJsonArray(Hit.ImpactNormal));
+    Result->SetNumberField(TEXT("distance"), Hit.Distance);
+    if (AActor* HitActor = Hit.GetActor())
+    {
+        Result->SetStringField(TEXT("actor"), HitActor->GetName());
+#if WITH_EDITOR
+        Result->SetStringField(TEXT("actorLabel"), HitActor->GetActorLabel());
+#endif
+    }
+    if (UPrimitiveComponent* HitComp = Hit.GetComponent())
+    {
+        Result->SetStringField(TEXT("component"), HitComp->GetName());
+    }
+
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleMapCheck(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    const bool bIncludeWarnings = !Params->HasField(TEXT("includeWarnings")) || Params->GetBoolField(TEXT("includeWarnings"));
+    int32 Limit = 200;
+    if (Params->HasField(TEXT("limit")))
+    {
+        Limit = (int32)Params->GetNumberField(TEXT("limit"));
+    }
+    Limit = FMath::Clamp(Limit, 1, 1000);
+
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    UWorld* World = GEditor->GetEditorWorldContext().World();
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    FMessageLogModule& MessageLogModule = FModuleManager::LoadModuleChecked<FMessageLogModule>(TEXT("MessageLog"));
+    const TSharedRef<IMessageLogListing> Listing = MessageLogModule.GetLogListing(TEXT("MapCheck"));
+    Listing->ClearMessages();
+
+    FOutputDeviceNull Ar;
+    // Use the editor's exec pathway so we can request "don't display dialog" without relying on private enums.
+    const bool bOk = GEditor->Exec(World, TEXT("MAP CHECK DONTDISPLAYDIALOG"), Ar);
+    if (!bOk)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to run Map Check."));
+    }
+
+    const TArray<TSharedRef<FTokenizedMessage>>& Messages = Listing->GetFilteredMessages();
+    int32 ErrorCount = 0;
+    int32 WarningCount = 0;
+    int32 IncludedMessageCount = 0;
+    bool bTruncated = false;
+
+    TArray<TSharedPtr<FJsonValue>> Issues;
+    for (const TSharedRef<FTokenizedMessage>& Message : Messages)
+    {
+        const EMessageSeverity::Type Severity = Message->GetSeverity();
+        const bool bIsWarning =
+            Severity == EMessageSeverity::Warning || Severity == EMessageSeverity::PerformanceWarning;
+        const bool bIsError = Severity == EMessageSeverity::Error || Severity == EMessageSeverity::CriticalError;
+
+        if (bIsError) ErrorCount++;
+        if (bIsWarning) WarningCount++;
+
+        if (!bIncludeWarnings && bIsWarning) continue;
+
+        IncludedMessageCount++;
+        if (Issues.Num() >= Limit)
+        {
+            bTruncated = true;
+            continue;
+        }
+
+        TSharedPtr<FJsonObject> Issue = MakeShared<FJsonObject>();
+        Issue->SetStringField(TEXT("severity"), MessageSeverityToString(Severity));
+        Issue->SetStringField(TEXT("message"), Message->ToText().ToString());
+        Issues.Add(MakeShared<FJsonValueObject>(Issue));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetBoolField(TEXT("ok"), ErrorCount == 0);
+    Result->SetNumberField(TEXT("errors"), ErrorCount);
+    Result->SetNumberField(TEXT("warnings"), WarningCount);
+    Result->SetBoolField(TEXT("includeWarnings"), bIncludeWarnings);
+    Result->SetArrayField(TEXT("issues"), Issues);
+    Result->SetBoolField(TEXT("truncated"), bTruncated || IncludedMessageCount > Issues.Num());
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetEditorContext(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    UWorld* World = GEditor->GetEditorWorldContext().World();
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    const FDateTime Now = FDateTime::UtcNow();
+    const int64 TimestampMs = Now.ToUnixTimestamp() * 1000 + Now.GetMillisecond();
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetNumberField(TEXT("timestampMs"), (double)TimestampMs);
+
+    const FString MapPackage = World->GetOutermost() ? World->GetOutermost()->GetName() : World->GetMapName();
+    Result->SetStringField(TEXT("map"), MapPackage);
+
+    // Selection (editor)
+    TArray<TSharedPtr<FJsonValue>> Selection;
+    if (USelection* SelectedActors = GEditor->GetSelectedActors())
+    {
+        for (FSelectionIterator It(*SelectedActors); It; ++It)
+        {
+            if (AActor* Actor = Cast<AActor>(*It))
+            {
+                TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+                Obj->SetStringField(TEXT("name"), Actor->GetName());
+#if WITH_EDITOR
+                Obj->SetStringField(TEXT("label"), Actor->GetActorLabel());
+#endif
+                Obj->SetArrayField(TEXT("location"), VectorToJsonArray(Actor->GetActorLocation()));
+                Obj->SetArrayField(TEXT("rotation"), RotatorToJsonArray(Actor->GetActorRotation()));
+                Selection.Add(MakeShared<FJsonValueObject>(Obj));
+            }
+        }
+    }
+    Result->SetArrayField(TEXT("selection"), Selection);
+
+    // Active viewport camera (best-effort)
+    TSharedPtr<FJsonObject> ViewportCamera;
+    FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
+    if (LevelEditorModule)
+    {
+        TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
+        if (ActiveViewport.IsValid())
+        {
+            const FEditorViewportClient& VC = ActiveViewport->GetAssetViewportClient();
+            ViewportCamera = MakeShared<FJsonObject>();
+            ViewportCamera->SetArrayField(TEXT("location"), VectorToJsonArray(VC.GetViewLocation()));
+            ViewportCamera->SetArrayField(TEXT("rotation"), RotatorToJsonArray(VC.GetViewRotation()));
+            ViewportCamera->SetNumberField(TEXT("fov"), VC.ViewFOV);
+            ViewportCamera->SetArrayField(TEXT("forward"), VectorToJsonArray(VC.GetViewRotation().Vector()));
+        }
+    }
+    if (ViewportCamera.IsValid())
+    {
+        Result->SetObjectField(TEXT("viewportCamera"), ViewportCamera);
+    }
+    else
+    {
+        Result->SetField(TEXT("viewportCamera"), MakeShared<FJsonValueNull>());
+    }
+
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetPlayerContext(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    UWorld* PlayWorld = GEditor->PlayWorld;
+    const bool bIsPlaying = PlayWorld != nullptr;
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetBoolField(TEXT("isPlaying"), bIsPlaying);
+
+    if (!bIsPlaying)
+    {
+        Result->SetField(TEXT("pawn"), MakeShared<FJsonValueNull>());
+        Result->SetField(TEXT("camera"), MakeShared<FJsonValueNull>());
+        return Result;
+    }
+
+    APlayerController* PC = PlayWorld->GetFirstPlayerController();
+    if (!PC)
+    {
+        Result->SetField(TEXT("pawn"), MakeShared<FJsonValueNull>());
+        Result->SetField(TEXT("camera"), MakeShared<FJsonValueNull>());
+        return Result;
+    }
+
+    Result->SetStringField(TEXT("controller"), PC->GetName());
+
+    if (APawn* Pawn = PC->GetPawn())
+    {
+        TSharedPtr<FJsonObject> PawnObj = MakeShared<FJsonObject>();
+        PawnObj->SetStringField(TEXT("name"), Pawn->GetName());
+        PawnObj->SetArrayField(TEXT("location"), VectorToJsonArray(Pawn->GetActorLocation()));
+        PawnObj->SetArrayField(TEXT("rotation"), RotatorToJsonArray(Pawn->GetActorRotation()));
+        PawnObj->SetArrayField(TEXT("scale"), VectorToJsonArray(Pawn->GetActorScale3D()));
+        Result->SetObjectField(TEXT("pawn"), PawnObj);
+    }
+    else
+    {
+        Result->SetField(TEXT("pawn"), MakeShared<FJsonValueNull>());
+    }
+
+    FVector CamLoc;
+    FRotator CamRot;
+    PC->GetPlayerViewPoint(CamLoc, CamRot);
+
+    TSharedPtr<FJsonObject> CamObj = MakeShared<FJsonObject>();
+    CamObj->SetArrayField(TEXT("location"), VectorToJsonArray(CamLoc));
+    CamObj->SetArrayField(TEXT("rotation"), RotatorToJsonArray(CamRot));
+    CamObj->SetArrayField(TEXT("forward"), VectorToJsonArray(CamRot.Vector()));
+    Result->SetObjectField(TEXT("camera"), CamObj);
 
-TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetPlayInEditorStatus(const TSharedPtr<FJsonObject>& Params)
-{
-    return CreatePlayStatusResponse();
+    return Result;
 }
 
-TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditor(const TSharedPtr<FJsonObject>& Params)
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleRaycastFromCamera(const TSharedPtr<FJsonObject>& Params)
 {
+    const FString Source = Params->HasField(TEXT("source")) ? Params->GetStringField(TEXT("source")).ToLower() : TEXT("editor");
+    const float MaxDistance = Params->HasField(TEXT("maxDistance")) ? (float)Params->GetNumberField(TEXT("maxDistance")) : 10000.0f;
+
+    TArray<FString> Ignore;
+    if (Params->HasField(TEXT("ignoreActors")))
+    {
+        const TArray<TSharedPtr<FJsonValue>> Arr = Params->GetArrayField(TEXT("ignoreActors"));
+        for (const TSharedPtr<FJsonValue>& V : Arr)
+        {
+            if (V.IsValid() && V->Type == EJson::String)
+            {
+                const FString S = V->AsString().TrimStartAndEnd();
+                if (!S.IsEmpty()) Ignore.Add(S);
+            }
+        }
+    }
+
     if (!GEditor)
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
     }
 
-    if (GEditor->IsPlaySessionInProgress())
+    if (Source == TEXT("pie") || Source == TEXT("player") || Source == TEXT("runtime"))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+        UWorld* PlayWorld = GEditor->PlayWorld;
+        if (!PlayWorld)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("PIE is not running (no PlayWorld)."));
+        }
+        APlayerController* PC = PlayWorld->GetFirstPlayerController();
+        if (!PC)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("PIE is running but no player controller was found."));
+        }
+        FVector CamLoc;
+        FRotator CamRot;
+        PC->GetPlayerViewPoint(CamLoc, CamRot);
+        return RaycastInWorld(PlayWorld, CamLoc, CamRot.Vector(), MaxDistance, Ignore);
     }
 
-    // Use the active editor viewport, matching how the LevelEditor subsystem triggers PIE.
+    // Default: editor viewport camera.
     FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
     if (!LevelEditorModule)
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("LevelEditor module not available."));
     }
-
     TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
     if (!ActiveViewport.IsValid())
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No active level viewport. Click the viewport and retry."));
     }
 
-    FRequestPlaySessionParams SessionParams;
-    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
-    SessionParams.DestinationSlateViewport = ActiveViewport;
-
-    GEditor->RequestPlaySession(SessionParams);
-    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
-
-    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
-    ResultObj->SetBoolField(TEXT("requested"), true);
-    ResultObj->SetBoolField(TEXT("queued"), bQueued);
-    ResultObj->SetBoolField(TEXT("started"), bQueued);
-    ResultObj->SetStringField(TEXT("mode"), TEXT("pie"));
-    return ResultObj;
+    const FEditorViewportClient& VC = ActiveViewport->GetAssetViewportClient();
+    UWorld* World = GEditor->GetEditorWorldContext().World();
+    return RaycastInWorld(World, VC.GetViewLocation(), VC.GetViewRotation().Vector(), MaxDistance, Ignore);
 }
 
-TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditorWindowed(const TSharedPtr<FJsonObject>& Params)
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleRaycastDown(const TSharedPtr<FJsonObject>& Params)
 {
     if (!GEditor)
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
     }
 
-    if (GEditor->IsPlaySessionInProgress())
+    FString WorldSource = TEXT("editor");
+    if (Params->HasField(TEXT("source")))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+        WorldSource = Params->GetStringField(TEXT("source")).ToLower();
     }
 
-    // Match the editor's built-in "New Editor Window (PIE)" behavior by setting the play mode type and
-    // not specifying a DestinationSlateViewport.
-    ULevelEditorPlaySettings* PlaySettings = GetMutableDefault<ULevelEditorPlaySettings>();
-    if (PlaySettings)
+    FVector Start;
+    if (Params->HasField(TEXT("startLocation")))
     {
-        PlaySettings->LastExecutedPlayModeType = EPlayModeType::PlayMode_InEditorFloating;
+        Start = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("startLocation"));
+    }
+    else
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'startLocation' parameter"));
+    }
 
-        if (FProperty* Prop = ULevelEditorPlaySettings::StaticClass()->FindPropertyByName(
-                GET_MEMBER_NAME_CHECKED(ULevelEditorPlaySettings, LastExecutedPlayModeType)))
+    const float MaxDistance = Params->HasField(TEXT("maxDistance")) ? (float)Params->GetNumberField(TEXT("maxDistance")) : 100000.0f;
+
+    UWorld* World = nullptr;
+    if (WorldSource == TEXT("pie"))
+    {
+        World = GEditor->PlayWorld;
+        if (!World)
         {
-            FPropertyChangedEvent PropChangeEvent(Prop);
-            PlaySettings->PostEditChangeProperty(PropChangeEvent);
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("PIE is not running (no PlayWorld)."));
         }
-
-        PlaySettings->SaveConfig();
+    }
+    else
+    {
+        World = GEditor->GetEditorWorldContext().World();
     }
 
-    const bool bAtPlayerStart =
-        PlaySettings && PlaySettings->LastExecutedPlayModeLocation == EPlayModeLocations::PlayLocation_DefaultPlayerStart;
+    return RaycastInWorld(World, Start, FVector(0.0f, 0.0f, -1.0f), MaxDistance, {});
+}
 
-    FRequestPlaySessionParams SessionParams;
-    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorTransform(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
 
-    // If the user is playing from current camera location, use the active viewport camera as the start transform.
-    if (!bAtPlayerStart)
+    FString Name;
+    if (!Params->TryGetStringField(TEXT("name"), Name) && !Params->TryGetStringField(TEXT("actor"), Name))
     {
-        FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
-        if (LevelEditorModule)
-        {
-            TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
-            if (ActiveViewport.IsValid() && FSlateApplication::IsInitialized() &&
-                FSlateApplication::Get().FindWidgetWindow(ActiveViewport->AsWidget()).IsValid())
-            {
-                SessionParams.StartLocation = ActiveViewport->GetAssetViewportClient().GetViewLocation();
-                SessionParams.StartRotation = ActiveViewport->GetAssetViewportClient().GetViewRotation();
-            }
-        }
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+    Name = Name.TrimStartAndEnd();
+    if (Name.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Actor name is empty"));
     }
 
-    GEditor->RequestPlaySession(SessionParams);
-    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
+    FString Source = Params->HasField(TEXT("source")) ? Params->GetStringField(TEXT("source")).ToLower() : TEXT("editor");
+    UWorld* World = nullptr;
+    if (Source == TEXT("pie"))
+    {
+        World = GEditor->PlayWorld;
+    }
+    else
+    {
+        World = GEditor->GetEditorWorldContext().World();
+    }
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("World is not available."));
+    }
 
-    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
-    ResultObj->SetBoolField(TEXT("requested"), true);
-    ResultObj->SetBoolField(TEXT("queued"), bQueued);
-    ResultObj->SetBoolField(TEXT("started"), bQueued);
-    ResultObj->SetStringField(TEXT("mode"), TEXT("pie_new_window"));
-    return ResultObj;
+    AActor* Actor = FindActorByNameOrLabel(World, Name);
+    if (!Actor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *Name));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("name"), Actor->GetName());
+#if WITH_EDITOR
+    Result->SetStringField(TEXT("label"), Actor->GetActorLabel());
+#endif
+    Result->SetArrayField(TEXT("location"), VectorToJsonArray(Actor->GetActorLocation()));
+    Result->SetArrayField(TEXT("rotation"), RotatorToJsonArray(Actor->GetActorRotation()));
+    Result->SetArrayField(TEXT("scale"), VectorToJsonArray(Actor->GetActorScale3D()));
+    return Result;
 }
 
-TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleStopPlayInEditor(const TSharedPtr<FJsonObject>& Params)
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorBounds(const TSharedPtr<FJsonObject>& Params)
 {
     if (!GEditor)
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
     }
 
-    if (GEditor->IsPlaySessionRequestQueued() && !GEditor->IsPlayingSessionInEditor())
+    FString Name;
+    if (!Params->TryGetStringField(TEXT("name"), Name) && !Params->TryGetStringField(TEXT("actor"), Name))
     {
-        GEditor->CancelRequestPlaySession();
-        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
-        ResultObj->SetBoolField(TEXT("stopped"), true);
-        ResultObj->SetBoolField(TEXT("canceled"), true);
-        return ResultObj;
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+    Name = Name.TrimStartAndEnd();
+    if (Name.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Actor name is empty"));
     }
 
-    if (!GEditor->IsPlayingSessionInEditor())
+    FString Source = Params->HasField(TEXT("source")) ? Params->GetStringField(TEXT("source")).ToLower() : TEXT("editor");
+    UWorld* World = nullptr;
+    if (Source == TEXT("pie"))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No play session is running."));
+        World = GEditor->PlayWorld;
+    }
+    else
+    {
+        World = GEditor->GetEditorWorldContext().World();
+    }
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("World is not available."));
     }
 
-    GEditor->RequestEndPlayMap();
+    AActor* Actor = FindActorByNameOrLabel(World, Name);
+    if (!Actor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *Name));
+    }
 
-    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
-    ResultObj->SetBoolField(TEXT("stopped"), true);
-    return ResultObj;
+    FVector Origin;
+    FVector Extent;
+    Actor->GetActorBounds(true, Origin, Extent, false);
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("name"), Actor->GetName());
+#if WITH_EDITOR
+    Result->SetStringField(TEXT("label"), Actor->GetActorLabel());
+#endif
+    Result->SetArrayField(TEXT("origin"), VectorToJsonArray(Origin));
+    Result->SetArrayField(TEXT("extent"), VectorToJsonArray(Extent));
+    Result->SetArrayField(TEXT("min"), VectorToJsonArray(Origin - Extent));
+    Result->SetArrayField(TEXT("max"), VectorToJsonArray(Origin + Extent));
+    return Result;
 }
 
 TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorsInLevel(const TSharedPtr<FJsonObject>& Params)
@@ -295,10 +1446,15 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorsInLevel(const T
 TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleFindActorsByName(const TSharedPtr<FJsonObject>& Params)
 {
     FString Pattern;
-    if (!Params->TryGetStringField(TEXT("pattern"), Pattern))
+    if (!Params->TryGetStringField(TEXT("pattern"), Pattern) && !Params->TryGetStringField(TEXT("name"), Pattern))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'pattern' parameter"));
     }
+    Pattern = Pattern.TrimStartAndEnd();
+    if (Pattern.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("pattern is empty"));
+    }
     
     TArray<AActor*> AllActors;
     UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
@@ -306,7 +1462,14 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleFindActorsByName(const T
     TArray<TSharedPtr<FJsonValue>> MatchingActors;
     for (AActor* Actor : AllActors)
     {
-        if (Actor && Actor->GetName().Contains(Pattern))
+        if (!Actor) continue;
+        const bool bNameMatch = Actor->GetName().Contains(Pattern);
+#if WITH_EDITOR
+        const bool bLabelMatch = Actor->GetActorLabel().Contains(Pattern);
+#else
+        const bool bLabelMatch = false;
+#endif
+        if (bNameMatch || bLabelMatch)
         {
             MatchingActors.Add(FUnrealMCPCommonUtils::ActorToJson(Actor));
         }
@@ -453,6 +1616,196 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnActor(const TShared
     return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to create actor"));
 }
 
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleCreateLandscape(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    FString LandscapeName;
+    if (!Params->TryGetStringField(TEXT("name"), LandscapeName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+    LandscapeName = LandscapeName.TrimStartAndEnd();
+    if (LandscapeName.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Invalid 'name' parameter (empty)"));
+    }
+
+    // Ensure actor name uniqueness.
+    {
+        TArray<AActor*> AllActors;
+        UGameplayStatics::GetAllActorsOfClass(World, AActor::StaticClass(), AllActors);
+        for (AActor* Actor : AllActors)
+        {
+            if (Actor && Actor->GetName() == LandscapeName)
+            {
+                return FUnrealMCPCommonUtils::CreateErrorResponse(
+                    FString::Printf(TEXT("Actor with name '%s' already exists"), *LandscapeName));
+            }
+        }
+    }
+
+    FVector Location(0.0f, 0.0f, 0.0f);
+    FRotator Rotation(0.0f, 0.0f, 0.0f);
+    FVector Scale(100.0f, 100.0f, 100.0f);
+
+    if (Params->HasField(TEXT("location")))
+    {
+        Location = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location"));
+    }
+    if (Params->HasField(TEXT("rotation")))
+    {
+        Rotation = FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("rotation"));
+    }
+    if (Params->HasField(TEXT("scale")))
+    {
+        Scale = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("scale"));
+    }
+
+    int32 ComponentCountX = 8;
+    int32 ComponentCountY = 8;
+    int32 SectionsPerComponent = 1;
+    int32 QuadsPerSection = 63;
+
+    {
+        double Value = 0;
+        if (Params->TryGetNumberField(TEXT("componentCountX"), Value)) ComponentCountX = (int32)Value;
+        if (Params->TryGetNumberField(TEXT("componentCountY"), Value)) ComponentCountY = (int32)Value;
+        if (Params->TryGetNumberField(TEXT("sectionsPerComponent"), Value)) SectionsPerComponent = (int32)Value;
+        if (Params->TryGetNumberField(TEXT("quadsPerSection"), Value)) QuadsPerSection = (int32)Value;
+    }
+
+    if (ComponentCountX <= 0 || ComponentCountY <= 0)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("componentCountX/componentCountY must be positive integers"));
+    }
+    if (SectionsPerComponent <= 0 || SectionsPerComponent > 2)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("sectionsPerComponent must be 1 or 2"));
+    }
+    if (QuadsPerSection <= 0)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("quadsPerSection must be a positive integer"));
+    }
+
+    const int32 QuadsPerComponent = SectionsPerComponent * QuadsPerSection;
+    const int32 SizeX = ComponentCountX * QuadsPerComponent + 1;
+    const int32 SizeY = ComponentCountY * QuadsPerComponent + 1;
+
+    const int64 TotalVerts = (int64)SizeX * (int64)SizeY;
+    if (TotalVerts > 16ll * 1024ll * 1024ll)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Landscape is too large (vertex count limit exceeded)"));
+    }
+
+    // Optional landscape material.
+    UMaterialInterface* LandscapeMaterial = nullptr;
+    {
+        FString MaterialPath;
+        if (Params->TryGetStringField(TEXT("materialPath"), MaterialPath) ||
+            Params->TryGetStringField(TEXT("material"), MaterialPath) ||
+            Params->TryGetStringField(TEXT("landscapeMaterial"), MaterialPath))
+        {
+            MaterialPath = MaterialPath.TrimStartAndEnd();
+            if (!MaterialPath.IsEmpty())
+            {
+                LandscapeMaterial = LoadObject<UMaterialInterface>(nullptr, *MaterialPath);
+                if (!LandscapeMaterial && !MaterialPath.StartsWith(TEXT("Material'")))
+                {
+                    LandscapeMaterial = LoadObject<UMaterialInterface>(nullptr, *FString::Printf(TEXT("Material'%s'"), *MaterialPath));
+                }
+                if (!LandscapeMaterial)
+                {
+                    return FUnrealMCPCommonUtils::CreateErrorResponse(
+                        FString::Printf(TEXT("Landscape material not found: %s"), *MaterialPath));
+                }
+            }
+        }
+    }
+
+    // Center on Location (similar to the editor create landscape UX).
+    const FVector Offset =
+        FTransform(Rotation, FVector::ZeroVector, Scale)
+            .TransformVector(FVector(-ComponentCountX * QuadsPerComponent / 2, -ComponentCountY * QuadsPerComponent / 2, 0));
+
+    FActorSpawnParameters SpawnParams;
+    SpawnParams.Name = *LandscapeName;
+    ALandscape* Landscape = World->SpawnActor<ALandscape>(Location + Offset, Rotation, SpawnParams);
+    if (!Landscape)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn Landscape actor"));
+    }
+
+    Landscape->SetActorRelativeScale3D(Scale);
+    if (LandscapeMaterial)
+    {
+        Landscape->LandscapeMaterial = LandscapeMaterial;
+    }
+
+    Landscape->StaticLightingLOD = FMath::DivideAndRoundUp(FMath::CeilLogTwo((SizeX * SizeY) / (2048 * 2048) + 1), (uint32)2);
+
+    // Flat heightmap.
+    TArray<uint16> HeightData;
+    HeightData.SetNumUninitialized(SizeX * SizeY);
+    for (int32 i = 0; i < HeightData.Num(); i++)
+    {
+        HeightData[i] = 32768;
+    }
+
+    TMap<FGuid, TArray<uint16>> HeightDataPerLayers;
+    HeightDataPerLayers.Add(FGuid(), MoveTemp(HeightData));
+
+    TMap<FGuid, TArray<FLandscapeImportLayerInfo>> MaterialLayerDataPerLayers;
+    MaterialLayerDataPerLayers.Add(FGuid(), TArray<FLandscapeImportLayerInfo>());
+
+    FString ReimportHeightmapFilePath;
+
+    Landscape->Import(
+        FGuid::NewGuid(),
+        0,
+        0,
+        SizeX - 1,
+        SizeY - 1,
+        SectionsPerComponent,
+        QuadsPerSection,
+        HeightDataPerLayers,
+        *ReimportHeightmapFilePath,
+        MaterialLayerDataPerLayers,
+        ELandscapeImportAlphamapType::Additive,
+        TArrayView<const FLandscapeLayer>());
+
+    ULandscapeInfo* LandscapeInfo = Landscape->GetLandscapeInfo();
+    if (!LandscapeInfo)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Landscape import failed (LandscapeInfo missing)"));
+    }
+
+    FActorLabelUtilities::SetActorLabelUnique(Landscape, LandscapeName);
+    LandscapeInfo->UpdateLayerInfoMap(Landscape);
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetObjectField(TEXT("landscape"), FUnrealMCPCommonUtils::ActorToJsonObject(Landscape));
+    ResultObj->SetNumberField(TEXT("componentCountX"), ComponentCountX);
+    ResultObj->SetNumberField(TEXT("componentCountY"), ComponentCountY);
+    ResultObj->SetNumberField(TEXT("sectionsPerComponent"), SectionsPerComponent);
+    ResultObj->SetNumberField(TEXT("quadsPerSection"), QuadsPerSection);
+    ResultObj->SetNumberField(TEXT("sizeX"), SizeX);
+    ResultObj->SetNumberField(TEXT("sizeY"), SizeY);
+    return ResultObj;
+}
+
 TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleDeleteActor(const TSharedPtr<FJsonObject>& Params)
 {
     {
@@ -554,7 +1907,7 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorProperties(const
 {
     // Get actor name
     FString ActorName;
-    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    if (!Params->TryGetStringField(TEXT("name"), ActorName) && !Params->TryGetStringField(TEXT("actor"), ActorName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
     }
@@ -594,7 +1947,7 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSetActorProperty(const T
 
     // Get actor name
     FString ActorName;
-    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    if (!Params->TryGetStringField(TEXT("name"), ActorName) && !Params->TryGetStringField(TEXT("actor"), ActorName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
     }
@@ -620,18 +1973,20 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSetActorProperty(const T
 
     // Get property name
     FString PropertyName;
-    if (!Params->TryGetStringField(TEXT("property_name"), PropertyName))
+    if (!Params->TryGetStringField(TEXT("property_name"), PropertyName) && !Params->TryGetStringField(TEXT("property"), PropertyName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'property_name' parameter"));
     }
 
     // Get property value
-    if (!Params->HasField(TEXT("property_value")))
+    if (!Params->HasField(TEXT("property_value")) && !Params->HasField(TEXT("value")))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'property_value' parameter"));
     }
     
-    TSharedPtr<FJsonValue> PropertyValue = Params->Values.FindRef(TEXT("property_value"));
+    TSharedPtr<FJsonValue> PropertyValue = Params->HasField(TEXT("property_value"))
+        ? Params->Values.FindRef(TEXT("property_value"))
+        : Params->Values.FindRef(TEXT("value"));
     
     // Set the property using our utility function
     FString ErrorMessage;
@@ -665,13 +2020,17 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnBlueprintActor(cons
 
     // Get required parameters
     FString BlueprintName;
-    if (!Params->TryGetStringField(TEXT("blueprint_name"), BlueprintName))
+    if (!Params->TryGetStringField(TEXT("blueprint_name"), BlueprintName) &&
+        !Params->TryGetStringField(TEXT("blueprint"), BlueprintName) &&
+        !Params->TryGetStringField(TEXT("blueprint_path"), BlueprintName) &&
+        !Params->TryGetStringField(TEXT("objectPath"), BlueprintName) &&
+        !Params->TryGetStringField(TEXT("object_path"), BlueprintName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'blueprint_name' parameter"));
     }
 
     FString ActorName;
-    if (!Params->TryGetStringField(TEXT("actor_name"), ActorName))
+    if (!Params->TryGetStringField(TEXT("actor_name"), ActorName) && !Params->TryGetStringField(TEXT("name"), ActorName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'actor_name' parameter"));
     }
@@ -681,19 +2040,51 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnBlueprintActor(cons
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Blueprint name is empty"));
     }
+    BlueprintName = BlueprintName.TrimStartAndEnd();
+    ActorName = ActorName.TrimStartAndEnd();
+
+    const auto SanitizeObjectName = [](const FString& In) -> FString {
+        FString Out;
+        Out.Reserve(In.Len());
+        for (int32 i = 0; i < In.Len(); i++)
+        {
+            const TCHAR Ch = In[i];
+            const bool bOk =
+                (Ch >= '0' && Ch <= '9') ||
+                (Ch >= 'A' && Ch <= 'Z') ||
+                (Ch >= 'a' && Ch <= 'z') ||
+                Ch == '_' || Ch == '-';
+            Out.AppendChar(bOk ? Ch : '_');
+        }
+        Out = Out.TrimStartAndEnd();
+        while (Out.Contains(TEXT("__")))
+        {
+            Out = Out.Replace(TEXT("__"), TEXT("_"));
+        }
+        if (Out.IsEmpty()) Out = TEXT("BPActor");
+        return Out;
+    };
 
-    FString Root      = TEXT("/Game/Blueprints/");
-    FString AssetPath = Root + BlueprintName;
+    const FString SafeActorBaseName = SanitizeObjectName(ActorName);
+
+    // Resolve an asset/object path:
+    // - If caller passes /Game/... treat as an object path/package path.
+    // - Otherwise assume /Game/Blueprints/<BlueprintName> (compat default).
+    FString AssetPath = BlueprintName;
+    if (!AssetPath.StartsWith(TEXT("/")))
+    {
+        AssetPath = TEXT("/Game/Blueprints/") + AssetPath;
+    }
 
-    if (!FPackageName::DoesPackageExist(AssetPath))
+    UObject* AssetObj = LoadObject<UObject>(nullptr, *AssetPath);
+    if (!AssetObj && !AssetPath.Contains(TEXT("'")))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Blueprint '%s' not found – it must reside under /Game/Blueprints"), *BlueprintName));
+        AssetObj = LoadObject<UObject>(nullptr, *FString::Printf(TEXT("Blueprint'%s'"), *AssetPath));
     }
 
-    UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *AssetPath);
-    if (!Blueprint)
+    if (!AssetObj)
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Blueprint not found: %s"), *BlueprintName));
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Failed to load blueprint asset: %s"), *AssetPath));
     }
 
     // Get transform parameters
@@ -727,12 +2118,45 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnBlueprintActor(cons
     SpawnTransform.SetScale3D(Scale);
 
     FActorSpawnParameters SpawnParams;
-    SpawnParams.Name = *ActorName;
+    SpawnParams.Name = MakeUniqueObjectName(World, AActor::StaticClass(), FName(*SafeActorBaseName));
+
+    UClass* ActorClass = nullptr;
+    if (UBlueprint* Blueprint = Cast<UBlueprint>(AssetObj))
+    {
+        ActorClass = Blueprint->GeneratedClass;
+    }
+    else if (UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(AssetObj))
+    {
+        ActorClass = BPGC;
+    }
+    else if (UClass* Class = Cast<UClass>(AssetObj))
+    {
+        ActorClass = Class;
+    }
+
+    if (!ActorClass || !ActorClass->IsChildOf(AActor::StaticClass()))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Loaded asset is not a spawnable Actor Blueprint/Class. Compile the Blueprint and retry."));
+    }
 
-    AActor* NewActor = World->SpawnActor<AActor>(Blueprint->GeneratedClass, SpawnTransform, SpawnParams);
+    AActor* NewActor = World->SpawnActor<AActor>(ActorClass, SpawnTransform, SpawnParams);
     if (NewActor)
     {
-        return FUnrealMCPCommonUtils::ActorToJsonObject(NewActor, true);
+        bool bDetailed = true;
+        if (Params->HasField(TEXT("include_details")))
+        {
+            bDetailed = Params->GetBoolField(TEXT("include_details"));
+        }
+        else if (Params->HasField(TEXT("detailed")))
+        {
+            bDetailed = Params->GetBoolField(TEXT("detailed"));
+        }
+        else if (Params->HasField(TEXT("includeProperties")))
+        {
+            bDetailed = Params->GetBoolField(TEXT("includeProperties"));
+        }
+
+        return FUnrealMCPCommonUtils::ActorToJsonObject(NewActor, bDetailed);
     }
 
     return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn blueprint actor"));