ue-mcp 1.2.4 → 1.3.0

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

@@ -22,6 +22,9 @@ private:
 	static TSharedPtr<FJsonValue> DeleteAsset(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> DeleteAssetBatch(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> BulkRename(const TSharedPtr<FJsonObject>& Params);
+	// Bounded redirector clean-up after a move (#908). Lives in
+	// AssetHandlers_Redirectors.cpp.
+	static TSharedPtr<FJsonValue> FixupRedirectors(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> CreateDataAsset(const TSharedPtr<FJsonObject>& Params);
 	// Bounded batch create-or-update of UDataAsset instances. Lives in
 	// AssetHandlers_BulkUpsert.cpp.
@@ -32,6 +35,9 @@ private:
 	// #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);
+	// A named subobject inside an existing asset's package (#975). Lives in
+	// AssetHandlers_Subobject.cpp.
+	static TSharedPtr<FJsonValue> CreateSubobject(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);
@@ -97,6 +103,8 @@ private:
 	static TSharedPtr<FJsonValue> SetStringTableEntry(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> RemoveStringTableEntry(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> ImportStringTable(const TSharedPtr<FJsonObject>& Params);
+	// CSV import with key-set validation and an explicit save result (#978).
+	static TSharedPtr<FJsonValue> ImportStringTableCsv(const TSharedPtr<FJsonObject>& Params);
 
 	// Export
 	static TSharedPtr<FJsonValue> ExportAsset(const TSharedPtr<FJsonObject>& Params);

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

@@ -205,7 +205,7 @@ TSharedPtr<FJsonValue> FAssetHandlers::BulkSetAssetProperties(const TSharedPtr<F
 			continue;
 		}
 
-		UObject* LoadedAsset = LoadObject<UObject>(nullptr, *AssetPath);
+		UObject* LoadedAsset = MCPLoadAssetObject(AssetPath);
 		if (!LoadedAsset)
 		{
 			RejectItem(BulkStatusNotFound, FString::Printf(TEXT("Preflight failed: could not load asset '%s'"), *AssetPath));

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

@@ -0,0 +1,503 @@
+// asset(bulk_read_properties) - read the same properties off many assets in
+// one call (#909).
+//
+// The reporter needed voice-management and concurrency settings across 582
+// SoundWave, SoundCue and MetaSoundSource assets. audio(list) does not report
+// those fields, and asset(read_properties) answers one asset per call, so the
+// question became a Python loop. This is the same shape as
+// level(query_components), one level up: the directory and class filters, the
+// property reads, the predicates and the aggregates all run in the editor, and
+// only the answer crosses the wire.
+//
+// This file exists as its own translation unit with its own registration so
+// the change lands without touching AssetHandlers.cpp.
+//
+// It never writes. Loading an asset to read it does not dirty its package, and
+// the response says so rather than asking to be believed.
+
+#include "AssetHandlers_BulkRead.h"
+
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "AssetRegistry/IAssetRegistry.h"
+#include "Engine/Blueprint.h"
+#include "HandlerEditorState.h"
+#include "HandlerQuery.h"
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+#include "Serialization/JsonSerializer.h"
+#include "Serialization/JsonWriter.h"
+#include "UObject/Package.h"
+
+namespace
+{
+	// Every one of these is here because the action it replaces was unbounded.
+	constexpr int32 MCPBulkReadDefaultRowLimit = 200;
+	constexpr int32 MCPBulkReadMaxRowLimit = 2000;
+	constexpr int32 MCPBulkReadDefaultMaxAssets = 2000;
+	constexpr int32 MCPBulkReadHardMaxAssets = 20000;
+	constexpr int32 MCPBulkReadMaxProperties = 32;
+	constexpr int32 MCPBulkReadMaxPredicates = 24;
+	constexpr int32 MCPBulkReadMaxGroups = 200;
+	constexpr int32 MCPBulkReadMaxCountByPaths = 8;
+	constexpr int32 MCPBulkReadMaxCountByValues = 64;
+	constexpr int32 MCPBulkReadDefaultGroupSamples = 5;
+	constexpr int32 MCPBulkReadMaxGroupSamples = 25;
+	constexpr int32 MCPBulkReadMaxExplicitPaths = 5000;
+
+	/**
+	 * A Blueprint asset's properties live on its generated class default
+	 * object, not on the UBlueprint wrapper, so reading `bCanEverTick` off the
+	 * wrapper would always report absent.
+	 */
+	UObject* MCPBulkReadTarget(UObject* Asset)
+	{
+		if (UBlueprint* Blueprint = Cast<UBlueprint>(Asset))
+		{
+			if (UClass* GeneratedClass = Blueprint->GeneratedClass)
+			{
+				if (UObject* CDO = GeneratedClass->GetDefaultObject())
+				{
+					return CDO;
+				}
+			}
+		}
+		return Asset;
+	}
+
+	/** Render one row set as pretty JSON for the outputPath variant. */
+	FString MCPBulkReadSerializeRows(const TArray<TSharedPtr<FJsonValue>>& Rows)
+	{
+		TSharedPtr<FJsonObject> Document = MakeShared<FJsonObject>();
+		Document->SetNumberField(TEXT("count"), Rows.Num());
+		Document->SetArrayField(TEXT("rows"), Rows);
+		FString Output;
+		const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&Output);
+		FJsonSerializer::Serialize(Document.ToSharedRef(), Writer);
+		return Output;
+	}
+}
+
+void FAssetBulkReadHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	// Loading hundreds of assets to read them takes longer than the default
+	// handler timeout allows, and a timeout here would look like a hang.
+	Registry.RegisterHandlerWithTimeout(
+		TEXT("bulk_read_asset_properties"), &BulkReadAssetProperties, 300.0f);
+}
+
+TSharedPtr<FJsonValue> FAssetBulkReadHandlers::BulkReadAssetProperties(const TSharedPtr<FJsonObject>& Params)
+{
+	MCP_CHECK_GAME_THREAD();
+
+	// ── Properties to read ──────────────────────────────────────────────────
+	TArray<FString> PropertyPaths;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* PropertyValues = nullptr;
+		if (Params->TryGetArrayField(TEXT("propertyNames"), PropertyValues) && PropertyValues)
+		{
+			PropertyPaths = JsonArrayToStringList(PropertyValues);
+		}
+	}
+	if (PropertyPaths.IsEmpty())
+	{
+		return MCPError(TEXT("Missing required 'propertyNames' array (dotted paths into nested structs are supported, e.g. 'CullDistance.Max')"));
+	}
+	if (PropertyPaths.Num() > MCPBulkReadMaxProperties)
+	{
+		return MCPError(FString::Printf(
+			TEXT("'propertyNames' exceeds the maximum of %d entries"), MCPBulkReadMaxProperties));
+	}
+
+	// ── Selection ───────────────────────────────────────────────────────────
+	TArray<FString> ExplicitPaths;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* PathValues = nullptr;
+		if (Params->TryGetArrayField(TEXT("assetPaths"), PathValues) && PathValues)
+		{
+			ExplicitPaths = JsonArrayToStringList(PathValues);
+		}
+	}
+	const FString Directory = OptionalString(Params, TEXT("directory"));
+	if (ExplicitPaths.IsEmpty() && Directory.IsEmpty())
+	{
+		return MCPError(TEXT("Pass either 'assetPaths' (explicit list) or 'directory' (with optional 'classNames')"));
+	}
+	if (ExplicitPaths.Num() > MCPBulkReadMaxExplicitPaths)
+	{
+		return MCPError(FString::Printf(
+			TEXT("'assetPaths' exceeds the maximum of %d entries"), MCPBulkReadMaxExplicitPaths));
+	}
+
+	const bool bRecursive = OptionalBool(Params, TEXT("recursive"), true);
+	const bool bMatchSubclasses = OptionalBool(Params, TEXT("matchSubclasses"), true);
+	const int32 MaxAssets = FMath::Clamp(
+		OptionalInt(Params, TEXT("maxAssets"), MCPBulkReadDefaultMaxAssets), 1, MCPBulkReadHardMaxAssets);
+
+	TArray<UClass*> ClassFilters;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* ClassValues = nullptr;
+		if (Params->TryGetArrayField(TEXT("classNames"), ClassValues) && ClassValues)
+		{
+			for (const FString& Spec : JsonArrayToStringList(ClassValues))
+			{
+				UClass* Resolved = MCPResolveClass(Spec, true);
+				if (!Resolved)
+				{
+					return MCPClassNotFoundError(Spec, TEXT("classNames"));
+				}
+				ClassFilters.Add(Resolved);
+			}
+		}
+	}
+
+	// ── Predicates and aggregates ───────────────────────────────────────────
+	TArray<MCPQuery::FPredicate> Predicates;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* WhereValues = nullptr;
+		Params->TryGetArrayField(TEXT("where"), WhereValues);
+		FString ParseError;
+		if (!MCPQuery::ParsePredicates(WhereValues, MCPBulkReadMaxPredicates, Predicates, ParseError))
+		{
+			return MCPError(ParseError);
+		}
+	}
+	const FString WhereMode = OptionalString(Params, TEXT("whereMode"), TEXT("all")).ToLower();
+	if (WhereMode != TEXT("all") && WhereMode != TEXT("any"))
+	{
+		return MCPError(TEXT("'whereMode' must be either 'all' or 'any'"));
+	}
+	const bool bSuspectOnly = OptionalBool(Params, TEXT("suspectOnly"), false);
+	if (bSuspectOnly)
+	{
+		if (WhereMode == TEXT("any") && Predicates.Num() > 0)
+		{
+			return MCPError(TEXT("'suspectOnly' cannot be combined with whereMode 'any'; add {field:'suspect', op:'isTrue'} to 'where' instead"));
+		}
+		MCPQuery::FPredicate Suspect;
+		Suspect.Field = TEXT("suspect");
+		Suspect.Op = TEXT("isTrue");
+		Predicates.Add(MoveTemp(Suspect));
+	}
+
+	const FString GroupBy = OptionalString(Params, TEXT("groupBy"));
+	const int32 GroupSamples = FMath::Clamp(
+		OptionalInt(Params, TEXT("sampleLimit"), MCPBulkReadDefaultGroupSamples), 0, MCPBulkReadMaxGroupSamples);
+	TArray<FString> CountByPaths;
+	{
+		const TArray<TSharedPtr<FJsonValue>>* CountByValues = nullptr;
+		if (Params->TryGetArrayField(TEXT("countBy"), CountByValues) && CountByValues)
+		{
+			CountByPaths = JsonArrayToStringList(CountByValues);
+		}
+	}
+	if (CountByPaths.Num() > MCPBulkReadMaxCountByPaths)
+	{
+		return MCPError(FString::Printf(
+			TEXT("'countBy' exceeds the maximum of %d paths"), MCPBulkReadMaxCountByPaths));
+	}
+
+	const bool bCountOnly = OptionalBool(Params, TEXT("countOnly"), false);
+	const int32 Limit = FMath::Clamp(
+		OptionalInt(Params, TEXT("limit"), MCPBulkReadDefaultRowLimit), 0, MCPBulkReadMaxRowLimit);
+	const int32 StartIndex = FMath::Max(0, OptionalInt(Params, TEXT("startIndex"), 0));
+	const FString OutputPath = OptionalString(Params, TEXT("outputPath"));
+
+	// ── Gather candidate asset paths ────────────────────────────────────────
+	TArray<FString> CandidatePaths;
+	bool bScanTruncated = false;
+	if (!ExplicitPaths.IsEmpty())
+	{
+		CandidatePaths = MoveTemp(ExplicitPaths);
+	}
+	else
+	{
+		FAssetRegistryModule& AssetRegistryModule =
+			FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+		IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+		FARFilter Filter;
+		Filter.bRecursivePaths = bRecursive;
+		Filter.PackagePaths.Add(FName(*Directory));
+		for (const UClass* Class : ClassFilters)
+		{
+			Filter.ClassPaths.Add(Class->GetClassPathName());
+		}
+		Filter.bRecursiveClasses = bMatchSubclasses;
+
+		TArray<FAssetData> Found;
+		AssetRegistry.GetAssets(Filter, Found);
+		for (const FAssetData& Data : Found)
+		{
+			if (Data.AssetClassPath.GetAssetName() == FName(TEXT("ObjectRedirector")))
+			{
+				continue;
+			}
+			CandidatePaths.Add(Data.GetObjectPathString());
+		}
+	}
+	CandidatePaths.Sort();
+	if (CandidatePaths.Num() > MaxAssets)
+	{
+		bScanTruncated = true;
+		CandidatePaths.SetNum(MaxAssets);
+	}
+
+	TArray<FString> DirtyBefore;
+	MCPEditorState::CollectDirtyEditorPackageNames(DirtyBefore);
+
+	// ── Read ────────────────────────────────────────────────────────────────
+	int32 Loaded = 0;
+	int32 Matched = 0;
+	TArray<FString> UnloadableAssets;
+	TArray<FString> ClassFilteredOut;
+	TArray<TSharedPtr<FJsonValue>> Rows;
+	TMap<FString, int32> GroupCounts;
+	TMap<FString, TArray<FString>> GroupSamplesByKey;
+	TArray<FString> GroupOrder;
+	TMap<FString, TMap<FString, int32>> CountByHistograms;
+	bool bGroupsTruncated = false;
+
+	for (const FString& AssetPath : CandidatePaths)
+	{
+		UObject* Asset = LoadObject<UObject>(nullptr, *AssetPath);
+		if (!Asset)
+		{
+			if (UnloadableAssets.Num() < 50)
+			{
+				UnloadableAssets.Add(AssetPath);
+			}
+			continue;
+		}
+		++Loaded;
+
+		// An explicit assetPaths list bypasses the registry filter, so the
+		// class filter has to be applied here too or classNames would silently
+		// mean nothing for that shape of request.
+		if (ClassFilters.Num() > 0)
+		{
+			bool bClassMatches = false;
+			for (UClass* Class : ClassFilters)
+			{
+				if (bMatchSubclasses ? Asset->IsA(Class) : (Asset->GetClass() == Class))
+				{
+					bClassMatches = true;
+					break;
+				}
+			}
+			if (!bClassMatches)
+			{
+				if (ClassFilteredOut.Num() < 50)
+				{
+					ClassFilteredOut.Add(AssetPath);
+				}
+				continue;
+			}
+		}
+
+		UObject* Target = MCPBulkReadTarget(Asset);
+
+		TSharedPtr<FJsonObject> Props = MakeShared<FJsonObject>();
+		TArray<FString> MissingProperties;
+		bool bAnyNull = false;
+		for (const FString& PropertyPath : PropertyPaths)
+		{
+			FString ResolvedType;
+			const TSharedPtr<FJsonValue> Value = MCPQuery::ReadDottedProperty(Target, PropertyPath, ResolvedType);
+			if (!Value.IsValid())
+			{
+				// Absent is not null. "This class has no such property" and
+				// "this property is unset" are different findings, and
+				// collapsing them is what makes an audit unactionable.
+				MissingProperties.Add(PropertyPath);
+				continue;
+			}
+			if (Value->Type == EJson::Null)
+			{
+				bAnyNull = true;
+			}
+			Props->SetField(PropertyPath, Value);
+		}
+
+		TSharedPtr<FJsonObject> Row = MakeShared<FJsonObject>();
+		Row->SetStringField(TEXT("assetPath"), Asset->GetPathName());
+		Row->SetStringField(TEXT("assetName"), Asset->GetName());
+		Row->SetStringField(TEXT("className"), Asset->GetClass()->GetName());
+		Row->SetStringField(TEXT("packagePath"), Asset->GetOutermost()->GetName());
+		if (Target != Asset)
+		{
+			Row->SetStringField(TEXT("readFrom"), Target->GetPathName());
+		}
+		Row->SetObjectField(TEXT("props"), Props);
+		Row->SetArrayField(TEXT("missingProperties"), MCPStringListToJson(MissingProperties));
+		Row->SetBoolField(TEXT("suspect"), MissingProperties.Num() > 0 || bAnyNull);
+
+		if (!MCPQuery::EvaluateAll(Predicates, Row, WhereMode == TEXT("all")))
+		{
+			continue;
+		}
+		++Matched;
+
+		if (!GroupBy.IsEmpty())
+		{
+			const FString Key = MCPQuery::ValueKey(MCPQuery::ResolvePath(Row, GroupBy));
+			if (int32* Existing = GroupCounts.Find(Key))
+			{
+				++(*Existing);
+			}
+			else if (GroupCounts.Num() < MCPBulkReadMaxGroups)
+			{
+				GroupCounts.Add(Key, 1);
+				GroupOrder.Add(Key);
+			}
+			else
+			{
+				bGroupsTruncated = true;
+			}
+			if (GroupCounts.Contains(Key))
+			{
+				TArray<FString>& Samples = GroupSamplesByKey.FindOrAdd(Key);
+				if (Samples.Num() < GroupSamples)
+				{
+					Samples.Add(Asset->GetName());
+				}
+			}
+		}
+
+		for (const FString& CountPath : CountByPaths)
+		{
+			TMap<FString, int32>& Histogram = CountByHistograms.FindOrAdd(CountPath);
+			const FString Key = MCPQuery::ValueKey(MCPQuery::ResolvePath(Row, CountPath));
+			if (int32* Existing = Histogram.Find(Key))
+			{
+				++(*Existing);
+			}
+			else if (Histogram.Num() < MCPBulkReadMaxCountByValues)
+			{
+				Histogram.Add(Key, 1);
+			}
+		}
+
+		if (!bCountOnly)
+		{
+			Rows.Add(MakeShared<FJsonValueObject>(Row));
+		}
+	}
+
+	// ── Response ────────────────────────────────────────────────────────────
+	auto Result = MCPSuccess();
+	Result->SetNumberField(TEXT("candidates"), CandidatePaths.Num());
+	Result->SetNumberField(TEXT("loaded"), Loaded);
+	Result->SetNumberField(TEXT("matched"), Matched);
+	Result->SetBoolField(TEXT("countOnly"), bCountOnly);
+	Result->SetBoolField(TEXT("scanTruncated"), bScanTruncated);
+	if (bScanTruncated)
+	{
+		Result->SetStringField(TEXT("scanNote"), FString::Printf(
+			TEXT("More than maxAssets (%d) candidates matched the selection; narrow 'directory' or 'classNames'."),
+			MaxAssets));
+	}
+	Result->SetArrayField(TEXT("unloadableAssets"), MCPStringListToJson(UnloadableAssets));
+	if (ClassFilteredOut.Num() > 0)
+	{
+		Result->SetArrayField(TEXT("classFilteredOut"), MCPStringListToJson(ClassFilteredOut));
+	}
+
+	if (!bCountOnly)
+	{
+		if (!OutputPath.IsEmpty())
+		{
+			// File output is the escape valve for a result set too large to be
+			// worth paging through. The rows still exist; they just do not go
+			// through the model's context to get to disk.
+			const FString Absolute = FPaths::ConvertRelativePathToFull(OutputPath);
+			if (!FFileHelper::SaveStringToFile(MCPBulkReadSerializeRows(Rows), *Absolute))
+			{
+				return MCPError(FString::Printf(TEXT("Failed to write 'outputPath': %s"), *Absolute));
+			}
+			Result->SetStringField(TEXT("outputPath"), Absolute);
+			Result->SetNumberField(TEXT("written"), Rows.Num());
+		}
+		else
+		{
+			const int32 First = FMath::Min(StartIndex, Rows.Num());
+			const int32 Last = FMath::Min(First + Limit, Rows.Num());
+			TArray<TSharedPtr<FJsonValue>> Page;
+			for (int32 Index = First; Index < Last; ++Index)
+			{
+				Page.Add(Rows[Index]);
+			}
+			Result->SetArrayField(TEXT("rows"), Page);
+			Result->SetNumberField(TEXT("returned"), Page.Num());
+			Result->SetNumberField(TEXT("startIndex"), StartIndex);
+			Result->SetNumberField(TEXT("limit"), Limit);
+			const int32 NextStartIndex = StartIndex + Page.Num();
+			Result->SetBoolField(TEXT("hasMore"), NextStartIndex < Rows.Num());
+			if (NextStartIndex < Rows.Num())
+			{
+				Result->SetNumberField(TEXT("nextStartIndex"), NextStartIndex);
+			}
+		}
+	}
+
+	if (!GroupBy.IsEmpty())
+	{
+		GroupOrder.Sort([&GroupCounts](const FString& A, const FString& B)
+		{
+			const int32 CountA = GroupCounts.FindChecked(A);
+			const int32 CountB = GroupCounts.FindChecked(B);
+			return CountA != CountB ? CountA > CountB : A < B;
+		});
+		TArray<TSharedPtr<FJsonValue>> GroupArray;
+		for (const FString& Key : GroupOrder)
+		{
+			TSharedPtr<FJsonObject> GroupObject = MakeShared<FJsonObject>();
+			GroupObject->SetStringField(TEXT("key"), Key);
+			GroupObject->SetNumberField(TEXT("count"), GroupCounts.FindChecked(Key));
+			if (const TArray<FString>* Samples = GroupSamplesByKey.Find(Key))
+			{
+				GroupObject->SetArrayField(TEXT("samples"), MCPStringListToJson(*Samples));
+			}
+			GroupArray.Add(MakeShared<FJsonValueObject>(GroupObject));
+		}
+		Result->SetStringField(TEXT("groupBy"), GroupBy);
+		Result->SetArrayField(TEXT("groups"), GroupArray);
+		Result->SetBoolField(TEXT("groupsTruncated"), bGroupsTruncated);
+	}
+
+	if (CountByPaths.Num() > 0)
+	{
+		TSharedPtr<FJsonObject> CountsObject = MakeShared<FJsonObject>();
+		for (const FString& CountPath : CountByPaths)
+		{
+			TSharedPtr<FJsonObject> Histogram = MakeShared<FJsonObject>();
+			if (const TMap<FString, int32>* Values = CountByHistograms.Find(CountPath))
+			{
+				for (const TPair<FString, int32>& Pair : *Values)
+				{
+					Histogram->SetNumberField(Pair.Key, Pair.Value);
+				}
+			}
+			CountsObject->SetObjectField(CountPath, Histogram);
+		}
+		Result->SetObjectField(TEXT("counts"), CountsObject);
+	}
+
+	// The read guarantee, asserted rather than assumed. Loading an asset to
+	// read it does not dirty its package; if something did, the caller sees
+	// which package rather than an unexplained unsaved-changes marker.
+	TArray<FString> DirtyAfter;
+	MCPEditorState::CollectDirtyEditorPackageNames(DirtyAfter);
+	for (const FString& Already : DirtyBefore)
+	{
+		DirtyAfter.Remove(Already);
+	}
+	Result->SetBoolField(TEXT("dirtiedPackages"), DirtyAfter.Num() > 0);
+	if (DirtyAfter.Num() > 0)
+	{
+		Result->SetArrayField(TEXT("dirtyPackages"), MCPStringListToJson(DirtyAfter));
+	}
+
+	return MCPResult(Result);
+}

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+
+/**
+ * asset(bulk_read_properties) (#909).
+ *
+ * Its own class rather than another FAssetHandlers member, with its own
+ * registration entry in BridgeServer.cpp, so this lands without touching
+ * AssetHandlers.cpp at all.
+ */
+class FAssetBulkReadHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	static TSharedPtr<FJsonValue> BulkReadAssetProperties(const TSharedPtr<FJsonObject>& Params);
+};

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

@@ -351,7 +351,7 @@ TSharedPtr<FJsonValue> FAssetHandlers::BulkRestoreDataAssets(const TSharedPtr<FJ
 				continue;
 			}
 
-			UObject* Asset = LoadObject<UObject>(nullptr, *AssetPath);
+			UObject* Asset = MCPLoadAssetObject(AssetPath);
 			if (!Asset)
 			{
 				Errors.Add(MakeShared<FJsonValueString>(FString::Printf(TEXT("Unable to load '%s' for rollback"), *AssetPath)));
@@ -510,7 +510,7 @@ TSharedPtr<FJsonValue> FAssetHandlers::BulkUpsertDataAssets(const TSharedPtr<FJs
 				*Prepared.DataClass->GetPathName()));
 		}
 
-		Prepared.ExistingAsset = LoadObject<UObject>(nullptr, *Prepared.AssetPath);
+		Prepared.ExistingAsset = MCPLoadAssetObject(Prepared.AssetPath);
 		if (Prepared.ExistingAsset)
 		{
 			if (OnConflict == TEXT("error"))

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

@@ -136,7 +136,7 @@ TSharedPtr<FJsonValue> FAssetHandlers::ListEnumValues(const TSharedPtr<FJsonObje
 	FString AssetPath;
 	if (auto Err = RequireStringAlt(Params, TEXT("assetPath"), TEXT("path"), AssetPath)) return Err;
 
-	UEnum* Enum = Cast<UEnum>(UEditorAssetLibrary::LoadAsset(AssetPath));
+	UEnum* Enum = LoadAssetByPath<UEnum>(AssetPath);
 	if (!Enum) return MCPError(FString::Printf(TEXT("Enum not found: %s"), *AssetPath));
 
 	TSharedPtr<FJsonObject> Res = MCPSuccess();
@@ -162,7 +162,7 @@ TSharedPtr<FJsonValue> FAssetHandlers::EditUserDefinedEnum(const TSharedPtr<FJso
 	FString Op;
 	if (auto Err = RequireString(Params, TEXT("op"), Op)) return Err;
 
-	UUserDefinedEnum* Enum = Cast<UUserDefinedEnum>(UEditorAssetLibrary::LoadAsset(AssetPath));
+	UUserDefinedEnum* Enum = LoadAssetByPath<UUserDefinedEnum>(AssetPath);
 	if (!Enum) return MCPError(FString::Printf(TEXT("UserDefinedEnum not found (native UEnums cannot be edited): %s"), *AssetPath));
 
 	TSharedPtr<FJsonObject> Res = MCPSuccess();