ue-mcp 1.1.21 → 1.1.23

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

@@ -171,6 +171,9 @@ void FAssetHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("delete_asset_batch"), &DeleteAssetBatch);
 	Registry.RegisterHandler(TEXT("bulk_rename_assets"), &BulkRename);
 	Registry.RegisterHandler(TEXT("create_data_asset"), &CreateDataAsset);
+	// #726: generic create-any-concrete-UObject-class asset (physical materials,
+	// curves, settings objects) - not restricted to UDataAsset subclasses.
+	Registry.RegisterHandler(TEXT("create_asset_by_class"), &CreateAssetByClass);
 	Registry.RegisterHandler(TEXT("save_asset"), &SaveAsset);
 	Registry.RegisterHandler(TEXT("save_all_dirty"), &SaveAllDirty);
 	Registry.RegisterHandler(TEXT("list_textures"), &ListTextures);
@@ -1869,6 +1872,111 @@ TSharedPtr<FJsonValue> FAssetHandlers::CreateDataAsset(const TSharedPtr<FJsonObj
 	return MCPResult(Result);
 }
 
+// #726: create an asset of any concrete UObject class. create_data_asset only
+// accepts UDataAsset subclasses, so "settings-object" classes (UPhysicalMaterial
+// subclasses, curves, etc.) had no native route and required execute_python with
+// a hand-picked UFactory. This resolves the class, creates the asset (IAssetTools
+// CreateAsset with a null factory NewObjects the exact class), applies optional
+// properties, and saves.
+TSharedPtr<FJsonValue> FAssetHandlers::CreateAssetByClass(const TSharedPtr<FJsonObject>& Params)
+{
+	FString Name;
+	if (auto Err = RequireString(Params, TEXT("name"), Name)) return Err;
+	FString PackagePath = OptionalString(Params, TEXT("packagePath"), TEXT("/Game"));
+	FString ClassName;
+	if (auto Err = RequireStringAlt(Params, TEXT("className"), TEXT("class"), ClassName)) return Err;
+
+	// Resolve the class by path or (loaded) name - same resolution as create_data_asset.
+	UClass* AssetClass = nullptr;
+	if (ClassName.StartsWith(TEXT("/")))
+	{
+		AssetClass = LoadClass<UObject>(nullptr, *ClassName);
+		if (!AssetClass) AssetClass = LoadObject<UClass>(nullptr, *ClassName);
+	}
+	if (!AssetClass)
+	{
+		FString Trimmed = ClassName;
+		Trimmed.RemoveFromEnd(TEXT("_C"));
+		for (TObjectIterator<UClass> It; It; ++It)
+		{
+			if (It->GetName() == Trimmed || It->GetName() == ClassName)
+			{
+				AssetClass = *It;
+				break;
+			}
+		}
+	}
+	if (!AssetClass)
+	{
+		return MCPError(FString::Printf(TEXT("Class not found: %s (pass full /Script/Module.ClassName or a loaded class name)"), *ClassName));
+	}
+
+	// Guard classes that cannot be standalone assets or need a specialized flow.
+	if (AssetClass->HasAnyClassFlags(CLASS_Abstract))
+	{
+		return MCPError(FString::Printf(TEXT("Class %s is abstract and cannot be instantiated as an asset"), *ClassName));
+	}
+	if (AssetClass->IsChildOf(AActor::StaticClass()) || AssetClass->IsChildOf(UActorComponent::StaticClass()))
+	{
+		return MCPError(FString::Printf(TEXT("Class %s is an actor/component, not an asset - use level(place_actor) / level(add_component_to_actor)"), *ClassName));
+	}
+
+	const FString FullPath = FString::Printf(TEXT("%s/%s.%s"), *PackagePath, *Name, *Name);
+	const FString OnConflict = OptionalString(Params, TEXT("onConflict"), TEXT("skip"));
+
+	auto Created = MCPCreateAssetIdempotent<UObject>(Name, PackagePath, OnConflict, AssetClass->GetName(), AssetClass, nullptr);
+	if (Created.EarlyReturn) return Created.EarlyReturn;
+	UObject* NewAsset = Created.Asset;
+
+	// Optional properties (recursive JSON-to-property setter), mirroring create_data_asset.
+	const TSharedPtr<FJsonObject>* PropsObj = nullptr;
+	int32 SetCount = 0;
+	TArray<FString> PropErrors;
+	if (Params->TryGetObjectField(TEXT("properties"), PropsObj) && PropsObj && (*PropsObj).IsValid())
+	{
+		for (const auto& Pair : (*PropsObj)->Values)
+		{
+			FProperty* Prop = AssetClass->FindPropertyByName(FName(*Pair.Key));
+			if (!Prop)
+			{
+				PropErrors.Add(FString::Printf(TEXT("Property not found: %s"), *Pair.Key));
+				continue;
+			}
+			void* Addr = Prop->ContainerPtrToValuePtr<void>(NewAsset);
+			FString SetErr;
+			if (MCPJsonProperty::SetJsonOnProperty(Prop, Addr, Pair.Value, SetErr))
+			{
+				SetCount++;
+			}
+			else
+			{
+				PropErrors.Add(FString::Printf(TEXT("Failed to set %s: %s"), *Pair.Key, *SetErr));
+			}
+		}
+	}
+
+	UEditorAssetLibrary::SaveAsset(FullPath);
+
+	auto Result = MCPSuccess();
+	MCPSetCreated(Result);
+	Result->SetStringField(TEXT("assetPath"), FullPath);
+	Result->SetStringField(TEXT("name"), Name);
+	Result->SetStringField(TEXT("className"), AssetClass->GetName());
+	Result->SetNumberField(TEXT("propertiesSet"), SetCount);
+	if (PropErrors.Num() > 0)
+	{
+		TArray<TSharedPtr<FJsonValue>> Errs;
+		for (const FString& E : PropErrors) Errs.Add(MakeShared<FJsonValueString>(E));
+		Result->SetArrayField(TEXT("propertyErrors"), Errs);
+	}
+
+	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+	Payload->SetStringField(TEXT("assetPath"), FullPath);
+	MCPSetRollback(Result, TEXT("delete_asset"), Payload);
+
+	return MCPResult(Result);
+}
+
 TSharedPtr<FJsonValue> FAssetHandlers::SaveAsset(const TSharedPtr<FJsonObject>& Params)
 {
 	FString AssetPath;

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AssetHandlers.h

@@ -23,6 +23,9 @@ private:
 	static TSharedPtr<FJsonValue> DeleteAssetBatch(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> BulkRename(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> CreateDataAsset(const TSharedPtr<FJsonObject>& Params);
+	// #726: create an asset of any concrete UObject class via its registered
+	// factory (or NewObject fallback), not just UDataAsset subclasses.
+	static TSharedPtr<FJsonValue> CreateAssetByClass(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> SaveAsset(const TSharedPtr<FJsonObject>& Params);
 	// #429: bulk save of every dirty package - one-shot end-of-workflow flush.
 	static TSharedPtr<FJsonValue> SaveAllDirty(const TSharedPtr<FJsonObject>& Params);

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

@@ -3,6 +3,7 @@
 #include "HandlerUtils.h"
 #include "HandlerAssetCreate.h"
 #include "AssetRegistry/AssetRegistryModule.h"
+#include "AssetRegistry/ARFilter.h"
 #include "AssetToolsModule.h"
 #include "IAssetTools.h"
 #include "UObject/UObjectGlobals.h"
@@ -15,6 +16,7 @@
 #include "Factories/SoundCueFactoryNew.h"
 #include "AssetImportTask.h"
 #include "Misc/Paths.h"
+#include "Misc/Base64.h"
 #include "Dom/JsonObject.h"
 #include "Dom/JsonValue.h"
 #include "Kismet/GameplayStatics.h"
@@ -25,6 +27,7 @@
 void FAudioHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 {
 	Registry.RegisterHandler(TEXT("list_sound_assets"), &ListSoundAssets);
+	Registry.RegisterHandler(TEXT("extract_sound_wave_pcm"), &ExtractSoundWavePCM);
 	Registry.RegisterHandler(TEXT("import_audio"), &ImportAudio);
 	Registry.RegisterHandler(TEXT("create_sound_cue"), &CreateSoundCue);
 	Registry.RegisterHandler(TEXT("create_metasound_source"), &CreateMetaSoundSource);
@@ -151,37 +154,144 @@ TSharedPtr<FJsonValue> FAudioHandlers::ListSoundAssets(const TSharedPtr<FJsonObj
 {
 	auto Result = MCPSuccess();
 
-	bool bRecursive = OptionalBool(Params, TEXT("recursive"), true);
+	// #730: the old implementation ignored `directory`, had no result cap, and
+	// serialized SoundWave + SoundCue + MetaSoundSource for the whole project in
+	// one response. On projects with hundreds of SoundWaves that response could
+	// exceed the WebSocket framing threshold and drop the bridge. Honor the
+	// directory, filter recursively via a single FARFilter query, and paginate.
+	const FString Directory = OptionalString(Params, TEXT("directory"), TEXT("/Game"));
+	const bool bRecursive = OptionalBool(Params, TEXT("recursive"), true);
+	int32 MaxResults = OptionalInt(Params, TEXT("maxResults"), 1000);
+	if (MaxResults <= 0) MaxResults = 1000;
+	int32 Offset = OptionalInt(Params, TEXT("offset"), 0);
+	if (Offset < 0) Offset = 0;
 
 	IAssetRegistry& AssetRegistry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")).Get();
 
-	TArray<FTopLevelAssetPath> ClassPaths;
-	ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/Engine"), TEXT("SoundWave")));
-	ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/Engine"), TEXT("SoundCue")));
-	ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/MetasoundEngine"), TEXT("MetaSoundSource")));
+	FARFilter Filter;
+	Filter.ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/Engine"), TEXT("SoundWave")));
+	Filter.ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/Engine"), TEXT("SoundCue")));
+	Filter.ClassPaths.Add(FTopLevelAssetPath(TEXT("/Script/MetasoundEngine"), TEXT("MetaSoundSource")));
+	Filter.bRecursiveClasses = true;
+	Filter.PackagePaths.Add(FName(*Directory));
+	Filter.bRecursivePaths = bRecursive;
 
+	TArray<FAssetData> AssetDataList;
+	AssetRegistry.GetAssets(Filter, AssetDataList);
+
+	// Stable ordering so pagination is deterministic across calls.
+	AssetDataList.Sort([](const FAssetData& A, const FAssetData& B)
+	{
+		return A.GetObjectPathString() < B.GetObjectPathString();
+	});
+
+	const int32 Total = AssetDataList.Num();
 	TArray<TSharedPtr<FJsonValue>> AssetsArray;
+	for (int32 Index = Offset; Index < Total && AssetsArray.Num() < MaxResults; ++Index)
+	{
+		const FAssetData& AssetData = AssetDataList[Index];
+		TSharedPtr<FJsonObject> AssetObj = MakeShared<FJsonObject>();
+		AssetObj->SetStringField(TEXT("name"), AssetData.AssetName.ToString());
+		AssetObj->SetStringField(TEXT("path"), AssetData.GetObjectPathString());
+		AssetObj->SetStringField(TEXT("class"), AssetData.AssetClassPath.GetAssetName().ToString());
+		AssetObj->SetStringField(TEXT("packagePath"), AssetData.PackagePath.ToString());
+		AssetsArray.Add(MakeShared<FJsonValueObject>(AssetObj));
+	}
 
-	for (const FTopLevelAssetPath& ClassPath : ClassPaths)
+	const int32 NextOffset = Offset + AssetsArray.Num();
+	Result->SetArrayField(TEXT("assets"), AssetsArray);
+	Result->SetNumberField(TEXT("count"), AssetsArray.Num());
+	Result->SetNumberField(TEXT("total"), Total);
+	Result->SetNumberField(TEXT("offset"), Offset);
+	Result->SetNumberField(TEXT("maxResults"), MaxResults);
+	Result->SetBoolField(TEXT("hasMore"), NextOffset < Total);
+	if (NextOffset < Total)
 	{
-		TArray<FAssetData> AssetDataList;
-		AssetRegistry.GetAssetsByClass(ClassPath, AssetDataList, bRecursive);
+		Result->SetNumberField(TEXT("nextOffset"), NextOffset);
+	}
+	Result->SetStringField(TEXT("directory"), Directory);
+
+	return MCPResult(Result);
+}
+
+// #729: decode a USoundWave's imported audio to in-memory PCM. UE Python does
+// not expose USoundWave::GetImportedSoundWaveData, so a semantic-search pipeline
+// (CLAP etc.) previously had no way to reach the samples without relying on the
+// original import file, which may have moved. This returns interleaved signed
+// 16-bit PCM, base64-encoded, plus the format metadata needed to feed a model.
+TSharedPtr<FJsonValue> FAudioHandlers::ExtractSoundWavePCM(const TSharedPtr<FJsonObject>& Params)
+{
+	FString SoundPath;
+	if (auto Err = RequireString(Params, TEXT("soundPath"), SoundPath)) return Err;
+
+	USoundWave* Wave = LoadObject<USoundWave>(nullptr, *SoundPath);
+	if (!Wave)
+	{
+		return MCPError(FString::Printf(TEXT("SoundWave not found: %s"), *SoundPath));
+	}
 
-		for (const FAssetData& AssetData : AssetDataList)
+#if WITH_EDITOR
+	TArray<uint8> RawPCM;
+	uint32 SampleRate = 0;
+	uint16 NumChannels = 0;
+	if (!Wave->GetImportedSoundWaveData(RawPCM, SampleRate, NumChannels)
+		|| RawPCM.Num() == 0 || SampleRate == 0 || NumChannels == 0)
+	{
+		return MCPError(TEXT("Failed to decode imported SoundWave data (no editor source data available for this asset)"));
+	}
+
+	// RawPCM is interleaved signed 16-bit little-endian across NumChannels.
+	int32 TotalFrames = (RawPCM.Num() / (int32)sizeof(int16)) / NumChannels;
+
+	// Optional decode window so callers can bound the response size (CLAP-style
+	// pipelines only need a few seconds). Default is the whole asset.
+	const double MaxSeconds = OptionalNumber(Params, TEXT("maxSeconds"), 0.0);
+	if (MaxSeconds > 0.0)
+	{
+		const int32 FrameCap = FMath::Clamp(FMath::FloorToInt(MaxSeconds * (double)SampleRate), 0, TotalFrames);
+		TotalFrames = FrameCap;
+	}
+
+	const bool bDownmix = OptionalBool(Params, TEXT("downmixMono"), false);
+	const int16* Samples = reinterpret_cast<const int16*>(RawPCM.GetData());
+
+	TArray<uint8> OutBytes;
+	int32 OutChannels = NumChannels;
+	if (bDownmix && NumChannels > 1)
+	{
+		OutChannels = 1;
+		OutBytes.SetNumUninitialized(TotalFrames * (int32)sizeof(int16));
+		int16* Dst = reinterpret_cast<int16*>(OutBytes.GetData());
+		for (int32 Frame = 0; Frame < TotalFrames; ++Frame)
 		{
-			TSharedPtr<FJsonObject> AssetObj = MakeShared<FJsonObject>();
-			AssetObj->SetStringField(TEXT("name"), AssetData.AssetName.ToString());
-			AssetObj->SetStringField(TEXT("path"), AssetData.GetObjectPathString());
-			AssetObj->SetStringField(TEXT("class"), AssetData.AssetClassPath.GetAssetName().ToString());
-			AssetObj->SetStringField(TEXT("packagePath"), AssetData.PackagePath.ToString());
-			AssetsArray.Add(MakeShared<FJsonValueObject>(AssetObj));
+			int32 Acc = 0;
+			for (int32 Ch = 0; Ch < NumChannels; ++Ch)
+			{
+				Acc += Samples[Frame * NumChannels + Ch];
+			}
+			Dst[Frame] = static_cast<int16>(Acc / NumChannels);
 		}
 	}
+	else
+	{
+		const int32 ByteCount = TotalFrames * NumChannels * (int32)sizeof(int16);
+		OutBytes.Append(RawPCM.GetData(), ByteCount);
+	}
 
-	Result->SetArrayField(TEXT("assets"), AssetsArray);
-	Result->SetNumberField(TEXT("count"), AssetsArray.Num());
+	const FString Base64 = FBase64::Encode(OutBytes);
 
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("soundPath"), SoundPath);
+	Result->SetNumberField(TEXT("sampleRate"), static_cast<double>(SampleRate));
+	Result->SetNumberField(TEXT("numChannels"), static_cast<double>(OutChannels));
+	Result->SetNumberField(TEXT("numFrames"), static_cast<double>(TotalFrames));
+	Result->SetNumberField(TEXT("durationSeconds"), SampleRate > 0 ? static_cast<double>(TotalFrames) / static_cast<double>(SampleRate) : 0.0);
+	Result->SetStringField(TEXT("format"), TEXT("pcm_s16le"));
+	Result->SetStringField(TEXT("pcmBase64"), Base64);
 	return MCPResult(Result);
+#else
+	return MCPError(TEXT("extract_sound_wave_pcm requires an editor build"));
+#endif
 }
 
 TSharedPtr<FJsonValue> FAudioHandlers::CreateSoundCue(const TSharedPtr<FJsonObject>& Params)

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/AudioHandlers.h

@@ -12,6 +12,8 @@ public:
 private:
 	// ── Assets + playback ──────────────────────────────────────────────
 	static TSharedPtr<FJsonValue> ListSoundAssets(const TSharedPtr<FJsonObject>& Params);
+	// #729: decode a USoundWave's imported audio to in-memory PCM for semantic search.
+	static TSharedPtr<FJsonValue> ExtractSoundWavePCM(const TSharedPtr<FJsonObject>& Params);
 	// #664: import a WAV/OGG file as a USoundWave asset.
 	static TSharedPtr<FJsonValue> ImportAudio(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> CreateSoundCue(const TSharedPtr<FJsonObject>& Params);

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

@@ -17,6 +17,12 @@
 #include "Dom/JsonObject.h"
 #include "Dom/JsonValue.h"
 #include "IPythonScriptPlugin.h"
+#include "LevelSequence.h"
+#include "LevelSequenceEditorBlueprintLibrary.h"
+#include "Framework/Docking/TabManager.h"
+#include "Widgets/Docking/SDockTab.h"
+#include "ISettingsModule.h"
+#include "Modules/ModuleManager.h"
 #include "Misc/ConfigCacheIni.h"
 #include "Misc/ConfigContext.h"
 #include "Misc/Paths.h"
@@ -24,6 +30,7 @@
 #include "Misc/FileHelper.h"
 #include "LevelEditorViewport.h"
 #include "UnrealClient.h"
+#include "Engine/GameViewportClient.h"
 #include "ContentStreaming.h"
 #include "RenderingThread.h"
 #include "Misc/AutomationTest.h"
@@ -211,6 +218,13 @@ void FEditorHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	// Kismet, anything user-defined). Pair with editor.invoke_function to
 	// drive GeometryScript ops from MCP without hand-writing each handler.
 	Registry.RegisterHandler(TEXT("list_function_libraries"), &ListFunctionLibraries);
+	// #718: close the open Level Sequence editor before destructive actor ops.
+	Registry.RegisterHandler(TEXT("close_sequence"), &CloseSequence);
+	// #719: purge cached embedded-Python modules by prefix for tool-dev iteration.
+	Registry.RegisterHandler(TEXT("purge_python_modules"), &PurgePythonModules);
+	// #727: open a registered editor tab / Project Settings viewer for visual evidence.
+	Registry.RegisterHandler(TEXT("open_tab"), &OpenTab);
+	Registry.RegisterHandler(TEXT("open_settings"), &OpenSettings);
 }
 
 TSharedPtr<FJsonValue> FEditorHandlers::ExecuteCommand(const TSharedPtr<FJsonObject>& Params)
@@ -245,9 +259,35 @@ TSharedPtr<FJsonValue> FEditorHandlers::ExecutePython(const TSharedPtr<FJsonObje
 
 	bool bSuccess = PythonPlugin->ExecPythonCommandEx(PythonCommand);
 
+	// #732: a first-class result channel. In ExecuteFile mode CommandResult is
+	// normally empty and a top-level `return` is illegal, so scripts were forced
+	// to use print() as transport - mixing application data with diagnostics and
+	// duplicating it across log_output/output. When the caller names a
+	// resultVariable, evaluate it in the Public (__main__) scope the script just
+	// ran in and surface it as `result`, leaving print()/log as diagnostics only.
+	FString ResultText = PythonCommand.CommandResult;
+	const FString ResultVariable = OptionalString(Params, TEXT("resultVariable"));
+	bool bResultVariableResolved = false;
+	if (bSuccess && !ResultVariable.IsEmpty())
+	{
+		FPythonCommandEx EvalCommand;
+		EvalCommand.Command = ResultVariable;
+		EvalCommand.ExecutionMode = EPythonCommandExecutionMode::EvaluateStatement;
+		EvalCommand.FileExecutionScope = EPythonFileExecutionScope::Public;
+		if (PythonPlugin->ExecPythonCommandEx(EvalCommand))
+		{
+			ResultText = EvalCommand.CommandResult;
+			bResultVariableResolved = true;
+		}
+	}
+
 	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
 	Result->SetBoolField(TEXT("success"), bSuccess);
-	Result->SetStringField(TEXT("result"), PythonCommand.CommandResult);
+	Result->SetStringField(TEXT("result"), ResultText);
+	if (!ResultVariable.IsEmpty())
+	{
+		Result->SetBoolField(TEXT("resultVariableResolved"), bResultVariableResolved);
+	}
 
 	TArray<TSharedPtr<FJsonValue>> LogArray;
 	for (const FPythonLogOutputEntry& Entry : PythonCommand.LogOutput)
@@ -313,10 +353,32 @@ TSharedPtr<FJsonValue> FEditorHandlers::RunPythonFile(const TSharedPtr<FJsonObje
 
 	bool bSuccess = PythonPlugin->ExecPythonCommandEx(PythonCommand);
 
+	// #732: same first-class result channel as execute_python. The file runs in
+	// the Public (__main__) scope, so a named resultVariable can be read back.
+	FString ResultText = PythonCommand.CommandResult;
+	const FString ResultVariable = OptionalString(Params, TEXT("resultVariable"));
+	bool bResultVariableResolved = false;
+	if (bSuccess && !ResultVariable.IsEmpty())
+	{
+		FPythonCommandEx EvalCommand;
+		EvalCommand.Command = ResultVariable;
+		EvalCommand.ExecutionMode = EPythonCommandExecutionMode::EvaluateStatement;
+		EvalCommand.FileExecutionScope = EPythonFileExecutionScope::Public;
+		if (PythonPlugin->ExecPythonCommandEx(EvalCommand))
+		{
+			ResultText = EvalCommand.CommandResult;
+			bResultVariableResolved = true;
+		}
+	}
+
 	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
 	Result->SetBoolField(TEXT("success"), bSuccess);
 	Result->SetStringField(TEXT("path"), FilePath);
-	Result->SetStringField(TEXT("result"), PythonCommand.CommandResult);
+	Result->SetStringField(TEXT("result"), ResultText);
+	if (!ResultVariable.IsEmpty())
+	{
+		Result->SetBoolField(TEXT("resultVariableResolved"), bResultVariableResolved);
+	}
 
 	TArray<TSharedPtr<FJsonValue>> LogArray;
 	FString CombinedOutput;
@@ -335,6 +397,150 @@ TSharedPtr<FJsonValue> FEditorHandlers::RunPythonFile(const TSharedPtr<FJsonObje
 	return MCPResult(Result);
 }
 
+// #719: UE's embedded Python caches imported modules for the whole editor
+// session, so after editing a pipeline tool on disk the editor keeps running
+// stale code until the modules are purged from sys.modules. sys.modules is
+// Python-runtime state with no C++ accessor, so the interpreter (a hard plugin
+// dependency) is the correct owner to drive. We emit per-module markers rather
+// than rely on eval repr/str ambiguity, then rebuild the list in C++.
+TSharedPtr<FJsonValue> FEditorHandlers::PurgePythonModules(const TSharedPtr<FJsonObject>& Params)
+{
+	FString Prefix;
+	if (auto Err = RequireString(Params, TEXT("prefix"), Prefix)) return Err;
+	if (Prefix.TrimStartAndEnd().IsEmpty())
+	{
+		return MCPError(TEXT("'prefix' must be non-empty (an empty prefix would purge every module)"));
+	}
+
+	IPythonScriptPlugin* PythonPlugin = IPythonScriptPlugin::Get();
+	if (!PythonPlugin || !PythonPlugin->IsPythonAvailable())
+	{
+		return MCPError(TEXT("Python scripting is not available"));
+	}
+
+	// Escape the prefix into a Python single-quoted literal.
+	FString Escaped = Prefix.Replace(TEXT("\\"), TEXT("\\\\")).Replace(TEXT("'"), TEXT("\\'"));
+
+	FString Code;
+	Code += TEXT("import sys as __mcp_sys\n");
+	Code += FString::Printf(TEXT("__mcp_names = [__m for __m in list(__mcp_sys.modules) if __m.startswith('%s')]\n"), *Escaped);
+	Code += TEXT("for __m in __mcp_names:\n");
+	Code += TEXT("    del __mcp_sys.modules[__m]\n");
+	Code += TEXT("    print('MCP_PURGED_ITEM:' + __m)\n");
+
+	FPythonCommandEx PythonCommand;
+	PythonCommand.Command = Code;
+	PythonCommand.ExecutionMode = EPythonCommandExecutionMode::ExecuteFile;
+	PythonCommand.FileExecutionScope = EPythonFileExecutionScope::Public;
+	const bool bSuccess = PythonPlugin->ExecPythonCommandEx(PythonCommand);
+	if (!bSuccess)
+	{
+		return MCPError(TEXT("Failed to purge Python modules (interpreter error)"));
+	}
+
+	TArray<TSharedPtr<FJsonValue>> Purged;
+	const FString Marker = TEXT("MCP_PURGED_ITEM:");
+	for (const FPythonLogOutputEntry& Entry : PythonCommand.LogOutput)
+	{
+		FString Line = Entry.Output;
+		int32 Idx = Line.Find(Marker);
+		if (Idx != INDEX_NONE)
+		{
+			FString Name = Line.RightChop(Idx + Marker.Len()).TrimStartAndEnd();
+			if (!Name.IsEmpty())
+			{
+				Purged.Add(MakeShared<FJsonValueString>(Name));
+			}
+		}
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("prefix"), Prefix);
+	Result->SetArrayField(TEXT("purged"), Purged);
+	Result->SetNumberField(TEXT("count"), Purged.Num());
+	return MCPResult(Result);
+}
+
+// #718: close the currently open Level Sequence editor. Open sequences
+// re-resolve possessables by name during actor destruction, which can mis-bind
+// or destabilize the editor, so bulk actor ops want the sequencer closed first.
+TSharedPtr<FJsonValue> FEditorHandlers::CloseSequence(const TSharedPtr<FJsonObject>& /*Params*/)
+{
+	ULevelSequence* Current = ULevelSequenceEditorBlueprintLibrary::GetCurrentLevelSequence();
+	const bool bWasOpen = Current != nullptr;
+	const FString OpenPath = bWasOpen ? Current->GetPathName() : FString();
+
+	ULevelSequenceEditorBlueprintLibrary::CloseLevelSequence();
+
+	auto Result = MCPSuccess();
+	Result->SetBoolField(TEXT("wasOpen"), bWasOpen);
+	if (bWasOpen)
+	{
+		Result->SetStringField(TEXT("closedSequence"), OpenPath);
+	}
+	return MCPResult(Result);
+}
+
+// #727: open a registered editor tab by ID (e.g. "ProjectSettings", "OutputLog")
+// so an agent can screenshot editor UI as evidence.
+TSharedPtr<FJsonValue> FEditorHandlers::OpenTab(const TSharedPtr<FJsonObject>& Params)
+{
+	FString TabId;
+	if (auto Err = RequireString(Params, TEXT("tabId"), TabId)) return Err;
+
+	TSharedPtr<SDockTab> Tab = FGlobalTabmanager::Get()->TryInvokeTab(FTabId(*TabId));
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("tabId"), TabId);
+	Result->SetBoolField(TEXT("opened"), Tab.IsValid());
+	if (!Tab.IsValid())
+	{
+		Result->SetBoolField(TEXT("success"), false);
+		Result->SetStringField(TEXT("error"), FString::Printf(TEXT("No registered tab with id '%s' (try 'ProjectSettings', 'OutputLog', 'ContentBrowserTab1', ...)"), *TabId));
+	}
+	return MCPResult(Result);
+}
+
+// #727: open (and navigate) a settings viewer - Project Settings / Editor
+// Preferences. section may be a bare section name (with category) or a dotted
+// "Category.Section" pair for convenience.
+TSharedPtr<FJsonValue> FEditorHandlers::OpenSettings(const TSharedPtr<FJsonObject>& Params)
+{
+	FString Container = OptionalString(Params, TEXT("container"), TEXT("Project"));
+	FString Category = OptionalString(Params, TEXT("category"));
+	FString Section = OptionalString(Params, TEXT("section"));
+
+	// Accept a combined "Category.Section" in `section` when `category` is absent.
+	if (Category.IsEmpty() && Section.Contains(TEXT(".")))
+	{
+		FString Left, Right;
+		if (Section.Split(TEXT("."), &Left, &Right))
+		{
+			Category = Left;
+			Section = Right;
+		}
+	}
+
+	ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
+	if (!SettingsModule)
+	{
+		return MCPError(TEXT("Settings module not available"));
+	}
+
+	// Make sure the viewer tab exists, then show the requested section.
+	FGlobalTabmanager::Get()->TryInvokeTab(FTabId(Container == TEXT("Editor") ? TEXT("EditorSettings") : TEXT("ProjectSettings")));
+	if (!Category.IsEmpty())
+	{
+		SettingsModule->ShowViewer(FName(*Container), FName(*Category), FName(*Section));
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("container"), Container);
+	Result->SetStringField(TEXT("category"), Category);
+	Result->SetStringField(TEXT("section"), Section);
+	return MCPResult(Result);
+}
+
 TSharedPtr<FJsonValue> FEditorHandlers::SetProperty(const TSharedPtr<FJsonObject>& Params)
 {
 	// #221/#230: TS schema documents `objectPath` but the dispatcher only
@@ -1042,9 +1248,37 @@ TSharedPtr<FJsonValue> FEditorHandlers::CaptureScreenshot(const TSharedPtr<FJson
 
 	if (bUsePie && PieWorld)
 	{
+		// #724: HighResShot renders the PIE world offscreen and (a) strips the
+		// debug canvas (AddOnScreenDebugMessage overlays) and (b) in
+		// Play-in-New-Window did not reliably resolve to the PIE game window.
+		// Capture the actual PIE game viewport with a normal screenshot request
+		// and bShowUI=true, so we get exactly what the player sees - HUD and the
+		// on-screen debug canvas included. The running game viewport consumes the
+		// pending request on its next Draw, so this targets the PIE window even
+		// in new-window mode. Fall back to HighResShot only if no game viewport.
+		FString FullPath = Filename;
+		if (FPaths::IsRelative(Filename))
+		{
+			FullPath = FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Screenshots"), Filename);
+		}
+
+		UGameViewportClient* GameViewport = PieWorld->GetGameViewport();
+		if (GameViewport && GameViewport->Viewport)
+		{
+			FScreenshotRequest::RequestScreenshot(FullPath, /*bShowUI=*/true, /*bAddFilenameSuffix=*/false);
+			GameViewport->Viewport->Invalidate();
+
+			auto Result = MCPSuccess();
+			Result->SetStringField(TEXT("filename"), FullPath);
+			Result->SetStringField(TEXT("target"), TEXT("pie"));
+			Result->SetBoolField(TEXT("includesDebugCanvas"), true);
+			Result->SetStringField(TEXT("note"), TEXT("PIE game-viewport screenshot queued (UI + on-screen debug canvas included); written asynchronously."));
+			return MCPResult(Result);
+		}
+
+		// Fallback: no resolvable game viewport (unusual) - dispatch HighResShot.
 		int32 Width = OptionalInt(Params, TEXT("width"), 1920);
 		int32 Height = OptionalInt(Params, TEXT("height"), 1080);
-		// Some callers pass a single 'resolution' (long edge); honour it as width.
 		double ResolutionScalar = 0.0;
 		if (Params->TryGetNumberField(TEXT("resolution"), ResolutionScalar) && ResolutionScalar > 0)
 		{
@@ -1057,7 +1291,8 @@ TSharedPtr<FJsonValue> FEditorHandlers::CaptureScreenshot(const TSharedPtr<FJson
 		Result->SetStringField(TEXT("filename"), Filename);
 		Result->SetStringField(TEXT("target"), TEXT("pie"));
 		Result->SetStringField(TEXT("consoleCommand"), ConsoleCmd);
-		Result->SetStringField(TEXT("note"), TEXT("HighResShot dispatched into PIE world; output lands in Saved/Screenshots/<map>/."));
+		Result->SetBoolField(TEXT("includesDebugCanvas"), false);
+		Result->SetStringField(TEXT("note"), TEXT("No game viewport resolved; HighResShot dispatched (debug canvas not captured). Output in Saved/Screenshots/<map>/."));
 		return MCPResult(Result);
 	}
 
@@ -1509,7 +1744,25 @@ TSharedPtr<FJsonValue> FEditorHandlers::OpenAsset(const TSharedPtr<FJsonObject>&
 
 TSharedPtr<FJsonValue> FEditorHandlers::RunStatCommand(const TSharedPtr<FJsonObject>& Params)
 {
-	FString Command = OptionalString(Params, TEXT("command"), TEXT("stat fps"));
+	// #722: callers naturally pass the stat name (e.g. name="unit"); the old
+	// handler only read "command" and silently defaulted to "stat fps" when the
+	// stat was passed as "name", so "unit" ran the FPS counter. Accept either:
+	// an explicit full "command", or a bare stat "name" that we prefix.
+	FString Command = OptionalString(Params, TEXT("command"));
+	if (Command.IsEmpty())
+	{
+		const FString StatName = OptionalString(Params, TEXT("name"));
+		if (!StatName.IsEmpty())
+		{
+			Command = StatName.StartsWith(TEXT("stat "), ESearchCase::IgnoreCase)
+				? StatName
+				: FString::Printf(TEXT("stat %s"), *StatName);
+		}
+		else
+		{
+			Command = TEXT("stat fps");
+		}
+	}
 
 	REQUIRE_EDITOR_WORLD(World);
 

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/EditorHandlers.h

@@ -115,6 +115,13 @@ private:
 	static TSharedPtr<FJsonValue> ExecutePython(const TSharedPtr<FJsonObject>& Params);
 	// #142: run a Python file with __file__/__name__ context populated
 	static TSharedPtr<FJsonValue> RunPythonFile(const TSharedPtr<FJsonObject>& Params);
+	// #719: purge cached embedded-Python modules by prefix (tool-dev iteration)
+	static TSharedPtr<FJsonValue> PurgePythonModules(const TSharedPtr<FJsonObject>& Params);
+	// #718: close the currently open Level Sequence editor
+	static TSharedPtr<FJsonValue> CloseSequence(const TSharedPtr<FJsonObject>& Params);
+	// #727: open a registered editor tab / the Project Settings viewer
+	static TSharedPtr<FJsonValue> OpenTab(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> OpenSettings(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> SetProperty(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> GetProperty(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> DescribeObject(const TSharedPtr<FJsonObject>& Params);