ue-mcp 1.1.21 → 1.1.23

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

@@ -490,21 +490,40 @@ TSharedPtr<FJsonValue> FGameplayHandlers::SetMappingModifiers(const TSharedPtr<F
 	}
 
 	// ── Triggers ──
+	// #725: triggers previously accepted only {type:"Hold"}; the more obvious
+	// {class:"/Script/EnhancedInput.InputTriggerHold"} was rejected. Worse, an
+	// unresolvable shape could leave a NULL entry in Mapping.Triggers, which
+	// trips AssetCheck on save. Build into a temp array, accept class OR type
+	// (mirroring modifiers, #649), apply nested "properties", and never append
+	// a null; report any failed specs instead of silently corrupting the asset.
+	TArray<TSharedPtr<FJsonValue>> FailedTriggers;
 	const TArray<TSharedPtr<FJsonValue>>* TriggersArr = nullptr;
 	if (Params->TryGetArrayField(TEXT("triggers"), TriggersArr) && TriggersArr)
 	{
-		Mapping.Triggers.Empty();
+		TArray<TObjectPtr<UInputTrigger>> NewTriggers;
 		for (const auto& TrigVal : *TriggersArr)
 		{
 			const TSharedPtr<FJsonObject>* TrigObj = nullptr;
-			if (!TrigVal->TryGetObject(TrigObj) || !TrigObj) continue;
+			if (!TrigVal->TryGetObject(TrigObj) || !TrigObj)
+			{
+				FailedTriggers.Add(MakeShared<FJsonValueString>(TEXT("(non-object trigger entry)")));
+				continue;
+			}
+
+			FString ClassPath;
+			(*TrigObj)->TryGetStringField(TEXT("class"), ClassPath);
+			UClass* TrigClass = nullptr;
+			if (!ClassPath.IsEmpty())
+			{
+				TrigClass = LoadClass<UInputTrigger>(nullptr, *ClassPath);
+				if (!TrigClass) TrigClass = LoadObject<UClass>(nullptr, *ClassPath);
+				if (!TrigClass) TrigClass = FindClassByShortName(ClassPath);
+				if (TrigClass && !TrigClass->IsChildOf(UInputTrigger::StaticClass())) TrigClass = nullptr;
+			}
 
 			FString TypeName;
 			(*TrigObj)->TryGetStringField(TEXT("type"), TypeName);
-			if (TypeName.IsEmpty()) continue;
-
-			// Resolve trigger class: try multiple patterns (#169 fix)
-			UClass* TrigClass = nullptr;
+			if (!TrigClass && !TypeName.IsEmpty())
 			{
 				TArray<FString> Candidates;
 				if (TypeName.StartsWith(TEXT("UInputTrigger")) || TypeName.StartsWith(TEXT("InputTrigger")))
@@ -524,45 +543,63 @@ TSharedPtr<FJsonValue> FGameplayHandlers::SetMappingModifiers(const TSharedPtr<F
 					TrigClass = nullptr;
 				}
 			}
+
 			if (!TrigClass)
 			{
+				FailedTriggers.Add(MakeShared<FJsonValueString>(ClassPath.IsEmpty() ? TypeName : ClassPath));
 				continue;
 			}
 
 			UInputTrigger* Trigger = NewObject<UInputTrigger>(IMC, TrigClass);
-
-			// Set properties via reflection (same pattern as modifiers)
-			for (const auto& Pair : (*TrigObj)->Values)
+			if (!Trigger)
 			{
-				if (Pair.Key == TEXT("type")) continue;
-
-				FProperty* Prop = TrigClass->FindPropertyByName(FName(*Pair.Key));
-				if (!Prop) continue;
-
-				void* PropAddr = Prop->ContainerPtrToValuePtr<void>(Trigger);
+				FailedTriggers.Add(MakeShared<FJsonValueString>(ClassPath.IsEmpty() ? TypeName : ClassPath));
+				continue;
+			}
 
-				if (FFloatProperty* FloatProp = CastField<FFloatProperty>(Prop))
-				{
-					double Val = 0;
-					Pair.Value->TryGetNumber(Val);
-					FloatProp->SetPropertyValue(PropAddr, (float)Val);
-				}
-				else if (FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Prop))
-				{
-					double Val = 0;
-					Pair.Value->TryGetNumber(Val);
-					DoubleProp->SetPropertyValue(PropAddr, Val);
-				}
-				else if (FBoolProperty* BoolProp = CastField<FBoolProperty>(Prop))
+			// Set properties via reflection. Accept both top-level fields and a
+			// nested "properties" object (same as modifiers).
+			auto ApplyTriggerProps = [&](const TSharedPtr<FJsonObject>& Obj)
+			{
+				for (const auto& Pair : Obj->Values)
 				{
-					bool Val = false;
-					Pair.Value->TryGetBool(Val);
-					BoolProp->SetPropertyValue(PropAddr, Val);
+					if (Pair.Key == TEXT("type") || Pair.Key == TEXT("class") || Pair.Key == TEXT("properties")) continue;
+					FProperty* Prop = TrigClass->FindPropertyByName(FName(*Pair.Key));
+					if (!Prop) continue;
+					void* PropAddr = Prop->ContainerPtrToValuePtr<void>(Trigger);
+					if (FFloatProperty* FloatProp = CastField<FFloatProperty>(Prop))
+					{
+						double Val = 0; Pair.Value->TryGetNumber(Val);
+						FloatProp->SetPropertyValue(PropAddr, (float)Val);
+					}
+					else if (FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Prop))
+					{
+						double Val = 0; Pair.Value->TryGetNumber(Val);
+						DoubleProp->SetPropertyValue(PropAddr, Val);
+					}
+					else if (FBoolProperty* BoolProp = CastField<FBoolProperty>(Prop))
+					{
+						bool Val = false; Pair.Value->TryGetBool(Val);
+						BoolProp->SetPropertyValue(PropAddr, Val);
+					}
+					else if (FIntProperty* IntProp = CastField<FIntProperty>(Prop))
+					{
+						double Val = 0; Pair.Value->TryGetNumber(Val);
+						IntProp->SetPropertyValue(PropAddr, (int32)Val);
+					}
 				}
+			};
+			ApplyTriggerProps(*TrigObj);
+			const TSharedPtr<FJsonObject>* PropsObj = nullptr;
+			if ((*TrigObj)->TryGetObjectField(TEXT("properties"), PropsObj) && PropsObj && (*PropsObj).IsValid())
+			{
+				ApplyTriggerProps(*PropsObj);
 			}
 
-			Mapping.Triggers.Add(Trigger);
+			NewTriggers.Add(Trigger);
 		}
+
+		Mapping.Triggers = NewTriggers;
 	}
 
 	// Mark dirty — caller can use asset(save) to persist (#197 fix)
@@ -577,6 +614,12 @@ TSharedPtr<FJsonValue> FGameplayHandlers::SetMappingModifiers(const TSharedPtr<F
 	Result->SetNumberField(TEXT("mappingIndex"), MappingIndex);
 	Result->SetNumberField(TEXT("modifierCount"), Mapping.Modifiers.Num());
 	Result->SetNumberField(TEXT("triggerCount"), Mapping.Triggers.Num());
+	if (FailedTriggers.Num() > 0)
+	{
+		// #725: tell the caller which trigger specs did not resolve rather than
+		// silently dropping them (or, worse, leaving a null entry behind).
+		Result->SetArrayField(TEXT("failedTriggers"), FailedTriggers);
+	}
 	return MCPResult(Result);
 }
 

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

@@ -9,6 +9,7 @@
 #include "Landscape.h"
 #include "LandscapeEditTypes.h"
 #include "LandscapeProxy.h"
+#include "LandscapeStreamingProxy.h"
 #include "LandscapeInfo.h"
 #include "LandscapeComponent.h"
 #include "LandscapeSplineActor.h"
@@ -38,6 +39,9 @@ void FLandscapeHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 	Registry.RegisterHandler(TEXT("create_landscape"), &CreateLandscape);
 	Registry.RegisterHandler(TEXT("create_landscape_layer_info"), &CreateLandscapeLayerInfo);
 	Registry.RegisterHandler(TEXT("get_landscape_material_usage_summary"), &GetMaterialUsageSummary);
+	// #733: World Partition landscape streaming-proxy enumeration + spatial lookup.
+	Registry.RegisterHandler(TEXT("list_landscape_proxies"), &ListLandscapeProxies);
+	Registry.RegisterHandler(TEXT("find_landscape_proxy_at"), &FindLandscapeProxyAt);
 }
 
 TSharedPtr<FJsonValue> FLandscapeHandlers::GetLandscapeInfo(const TSharedPtr<FJsonObject>& Params)
@@ -745,3 +749,99 @@ TSharedPtr<FJsonValue> FLandscapeHandlers::GetMaterialUsageSummary(const TShared
 	Result->SetNumberField(TEXT("totalNaniteComponents"), TotalNanite);
 	return MCPResult(Result);
 }
+
+// #733: enumerate LandscapeStreamingProxy actors currently loaded in the world,
+// with per-proxy world bounds and the parent Landscape count. On a World
+// Partition map, an unloaded proxy silently reads layer weights as 0, so a
+// measurement is only trustworthy once the covering proxy is confirmed loaded.
+// Unloaded proxies are not spawned as actors, so the actor iterator only yields
+// loaded ones - hence loaded is always true for enumerated entries; callers use
+// the count + bounds to reason about coverage.
+TSharedPtr<FJsonValue> FLandscapeHandlers::ListLandscapeProxies(const TSharedPtr<FJsonObject>& Params)
+{
+	REQUIRE_EDITOR_WORLD(World);
+
+	int32 ParentLandscapes = 0;
+	TArray<TSharedPtr<FJsonValue>> Proxies;
+	for (TActorIterator<AActor> It(World); It; ++It)
+	{
+		AActor* Actor = *It;
+		if (!Actor) continue;
+		if (Actor->IsA<ALandscape>())
+		{
+			ParentLandscapes++;
+			continue;
+		}
+		ALandscapeStreamingProxy* Proxy = Cast<ALandscapeStreamingProxy>(Actor);
+		if (!Proxy) continue;
+
+		FVector Origin, Extent;
+		Proxy->GetActorBounds(false, Origin, Extent);
+
+		TSharedPtr<FJsonObject> ProxyObj = MakeShared<FJsonObject>();
+		ProxyObj->SetStringField(TEXT("label"), Proxy->GetActorLabel());
+		ProxyObj->SetBoolField(TEXT("loaded"), true);
+
+		TSharedPtr<FJsonObject> Bounds = MakeShared<FJsonObject>();
+		TSharedPtr<FJsonObject> OriginObj = MakeShared<FJsonObject>();
+		OriginObj->SetNumberField(TEXT("x"), Origin.X);
+		OriginObj->SetNumberField(TEXT("y"), Origin.Y);
+		OriginObj->SetNumberField(TEXT("z"), Origin.Z);
+		TSharedPtr<FJsonObject> ExtentObj = MakeShared<FJsonObject>();
+		ExtentObj->SetNumberField(TEXT("x"), Extent.X);
+		ExtentObj->SetNumberField(TEXT("y"), Extent.Y);
+		ExtentObj->SetNumberField(TEXT("z"), Extent.Z);
+		Bounds->SetObjectField(TEXT("origin"), OriginObj);
+		Bounds->SetObjectField(TEXT("extent"), ExtentObj);
+		ProxyObj->SetObjectField(TEXT("worldBounds"), Bounds);
+
+		Proxies.Add(MakeShared<FJsonValueObject>(ProxyObj));
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetNumberField(TEXT("loadedProxies"), Proxies.Num());
+	Result->SetNumberField(TEXT("parentLandscapes"), ParentLandscapes);
+	Result->SetArrayField(TEXT("proxies"), Proxies);
+	Result->SetStringField(TEXT("note"), TEXT("World Partition unloaded proxies are not spawned as actors, so only loaded proxies are listed."));
+	return MCPResult(Result);
+}
+
+// #733: resolve which loaded LandscapeStreamingProxy's world bounds contain a
+// world X/Y. Returns the covering proxy (loaded:true) or loaded:false when no
+// loaded proxy covers the position - which usually means the covering proxy is
+// streamed out, making any 0-weight readback there ambiguous rather than real.
+TSharedPtr<FJsonValue> FLandscapeHandlers::FindLandscapeProxyAt(const TSharedPtr<FJsonObject>& Params)
+{
+	REQUIRE_EDITOR_WORLD(World);
+
+	if (!Params->HasField(TEXT("worldX")) || !Params->HasField(TEXT("worldY")))
+	{
+		return MCPError(TEXT("Missing 'worldX'/'worldY' world position"));
+	}
+	const double TargetX = OptionalNumber(Params, TEXT("worldX"), 0.0);
+	const double TargetY = OptionalNumber(Params, TEXT("worldY"), 0.0);
+
+	for (TActorIterator<AActor> It(World); It; ++It)
+	{
+		ALandscapeStreamingProxy* Proxy = Cast<ALandscapeStreamingProxy>(*It);
+		if (!Proxy) continue;
+
+		FVector Origin, Extent;
+		Proxy->GetActorBounds(false, Origin, Extent);
+		if (TargetX >= Origin.X - Extent.X && TargetX <= Origin.X + Extent.X &&
+			TargetY >= Origin.Y - Extent.Y && TargetY <= Origin.Y + Extent.Y)
+		{
+			auto Result = MCPSuccess();
+			Result->SetBoolField(TEXT("found"), true);
+			Result->SetBoolField(TEXT("loaded"), true);
+			Result->SetStringField(TEXT("label"), Proxy->GetActorLabel());
+			return MCPResult(Result);
+		}
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetBoolField(TEXT("found"), false);
+	Result->SetBoolField(TEXT("loaded"), false);
+	Result->SetStringField(TEXT("note"), TEXT("No loaded proxy covers this position; the covering proxy is likely streamed out, so weight/height readbacks here are ambiguous."));
+	return MCPResult(Result);
+}

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

@@ -26,4 +26,8 @@ private:
 	static TSharedPtr<FJsonValue> CreateLandscapeLayerInfo(const TSharedPtr<FJsonObject>& Params);
 	// v0.7.19 issue #150 — concise material + component count summary per proxy
 	static TSharedPtr<FJsonValue> GetMaterialUsageSummary(const TSharedPtr<FJsonObject>& Params);
+	// #733: enumerate loaded World Partition landscape streaming proxies with
+	// per-proxy world bounds, and resolve which proxy covers a world position.
+	static TSharedPtr<FJsonValue> ListLandscapeProxies(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> FindLandscapeProxyAt(const TSharedPtr<FJsonObject>& Params);
 };

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

@@ -89,6 +89,8 @@
 void FLevelHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
 {
 	Registry.RegisterHandler(TEXT("get_world_outliner"), &GetOutliner);
+	// #717: query/set per-actor editor-only visibility (temporarily hidden).
+	Registry.RegisterHandler(TEXT("set_editor_visibility"), &SetEditorVisibility);
 	Registry.RegisterHandler(TEXT("place_actor"), &PlaceActor);
 	Registry.RegisterHandler(TEXT("delete_actor"), &DeleteActor);
 	Registry.RegisterHandler(TEXT("get_actor_details"), &GetActorDetails);
@@ -180,6 +182,13 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 	int32 Limit = OptionalInt(Params, TEXT("limit"), 50);
 	bool bIncludeStreaming = OptionalBool(Params, TEXT("includeStreaming"), false);
 
+	// #717: optional tri-state filter on editor-only visibility. When present,
+	// only actors whose IsTemporarilyHiddenInEditor() matches are returned. The
+	// per-actor editorHidden flag is always reported so callers can find lights
+	// that are hidden in the viewport but still render in game.
+	bool bEditorHiddenFilterValue = false;
+	const bool bHasEditorHiddenFilter = Params->TryGetBoolField(TEXT("editorHidden"), bEditorHiddenFilterValue);
+
 	TArray<TSharedPtr<FJsonValue>> ActorsArray;
 	int32 TotalCount = 0;
 	int32 StreamingSkipped = 0;
@@ -213,6 +222,16 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 		{
 			continue;
 		}
+
+#if WITH_EDITOR
+		const bool bEditorHidden = Actor->IsTemporarilyHiddenInEditor();
+#else
+		const bool bEditorHidden = false;
+#endif
+		if (bHasEditorHiddenFilter && bEditorHidden != bEditorHiddenFilterValue)
+		{
+			continue;
+		}
 		if (ActorsArray.Num() >= Limit) break;
 
 		TSharedPtr<FJsonObject> ActorObj = MakeShared<FJsonObject>();
@@ -220,6 +239,7 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 		ActorObj->SetStringField(TEXT("label"), ActorLabel);
 		ActorObj->SetStringField(TEXT("class"), ActorClass);
 		ActorObj->SetStringField(TEXT("path"), Actor->GetPathName());
+		ActorObj->SetBoolField(TEXT("editorHidden"), bEditorHidden);
 
 		FVector Location = Actor->GetActorLocation();
 		TSharedPtr<FJsonObject> LocationObj = MakeShared<FJsonObject>();
@@ -262,6 +282,65 @@ TSharedPtr<FJsonValue> FLevelHandlers::GetOutliner(const TSharedPtr<FJsonObject>
 	return MCPResult(Result);
 }
 
+// #717: bulk set editor-only visibility (temporarily hidden in editor). Targets
+// either an explicit actorLabels list or every actor (all=true). Editor-hidden
+// actors still render in game, so unhiding them is a common cleanup step.
+TSharedPtr<FJsonValue> FLevelHandlers::SetEditorVisibility(const TSharedPtr<FJsonObject>& Params)
+{
+	REQUIRE_EDITOR_WORLD(World);
+
+	bool bHidden = false;
+	if (!Params->TryGetBoolField(TEXT("hidden"), bHidden))
+	{
+		return MCPError(TEXT("Missing 'hidden' parameter (true = hide in editor, false = show)"));
+	}
+
+	const bool bAll = OptionalBool(Params, TEXT("all"), false);
+
+	TSet<FString> TargetLabels;
+	const TArray<TSharedPtr<FJsonValue>>* LabelsArr = nullptr;
+	if (Params->TryGetArrayField(TEXT("actorLabels"), LabelsArr) && LabelsArr)
+	{
+		for (const TSharedPtr<FJsonValue>& V : *LabelsArr)
+		{
+			FString S;
+			if (V.IsValid() && V->TryGetString(S)) TargetLabels.Add(S);
+		}
+	}
+
+	if (!bAll && TargetLabels.Num() == 0)
+	{
+		return MCPError(TEXT("Provide 'actorLabels' (array) or 'all'=true"));
+	}
+
+	int32 Changed = 0;
+	int32 Matched = 0;
+	TArray<TSharedPtr<FJsonValue>> Affected;
+	for (TActorIterator<AActor> ActorIt(World); ActorIt; ++ActorIt)
+	{
+		AActor* Actor = *ActorIt;
+		if (!Actor) continue;
+		const FString Label = Actor->GetActorLabel();
+		if (!bAll && !TargetLabels.Contains(Label)) continue;
+		Matched++;
+#if WITH_EDITOR
+		if (Actor->IsTemporarilyHiddenInEditor() != bHidden)
+		{
+			Actor->SetIsTemporarilyHiddenInEditor(bHidden);
+			Changed++;
+			Affected.Add(MakeShared<FJsonValueString>(Label));
+		}
+#endif
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetBoolField(TEXT("hidden"), bHidden);
+	Result->SetNumberField(TEXT("matched"), Matched);
+	Result->SetNumberField(TEXT("changed"), Changed);
+	Result->SetArrayField(TEXT("affected"), Affected);
+	return MCPResult(Result);
+}
+
 TSharedPtr<FJsonValue> FLevelHandlers::PlaceActor(const TSharedPtr<FJsonObject>& Params)
 {
 	FString ActorClass;

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

@@ -13,6 +13,8 @@ public:
 private:
 	// Handler implementations
 	static TSharedPtr<FJsonValue> GetOutliner(const TSharedPtr<FJsonObject>& Params);
+	// #717: bulk set editor-only visibility (temporarily hidden in editor)
+	static TSharedPtr<FJsonValue> SetEditorVisibility(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> PlaceActor(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> DeleteActor(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> GetActorDetails(const TSharedPtr<FJsonObject>& Params);

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

@@ -131,6 +131,21 @@ TSharedPtr<FJsonValue> FLevelHandlers::SpawnLight(const TSharedPtr<FJsonObject>&
 		{
 			LightComponent->SetLightColor(LightColor);
 		}
+		// #723: attenuationRadius was accepted by the schema but never applied.
+		// It lives on the local-light components (point/spot/rect); directional
+		// and sky lights have no attenuation radius, so they ignore it.
+		double AttenuationRadius = 0.0;
+		if (Params->TryGetNumberField(TEXT("attenuationRadius"), AttenuationRadius) && AttenuationRadius > 0.0)
+		{
+			if (UPointLightComponent* PointComp = Cast<UPointLightComponent>(LightComponent))
+			{
+				PointComp->SetAttenuationRadius(static_cast<float>(AttenuationRadius));
+			}
+			else if (URectLightComponent* RectComp = Cast<URectLightComponent>(LightComponent))
+			{
+				RectComp->SetAttenuationRadius(static_cast<float>(AttenuationRadius));
+			}
+		}
 		LightComponent->SetVisibility(true);
 		LightComponent->MarkRenderStateDirty();
 	}

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

@@ -137,10 +137,15 @@ TSharedPtr<FJsonValue> FPhysicsHandlers::SetPhysicsEnabled(const TSharedPtr<FJso
 	FString ActorLabel;
 	if (auto Err = RequireString(Params, TEXT("actorLabel"), ActorLabel)) return Err;
 
+	// #721: the published TS schema names this parameter "simulate" while the
+	// handler historically read only "enabled", so a schema-conformant call
+	// silently no-opped. Accept either spelling (simulate | enabled) and error
+	// explicitly when neither is present rather than succeeding silently.
 	bool bEnabled = true;
-	if (!Params->TryGetBoolField(TEXT("enabled"), bEnabled))
+	if (!Params->TryGetBoolField(TEXT("simulate"), bEnabled) &&
+		!Params->TryGetBoolField(TEXT("enabled"), bEnabled))
 	{
-		return MCPError(TEXT("Missing 'enabled' parameter (true/false)"));
+		return MCPError(TEXT("Missing 'simulate' (aka 'enabled') parameter (true/false)"));
 	}
 
 	REQUIRE_EDITOR_WORLD(World);

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

@@ -571,8 +571,12 @@ TSharedPtr<FJsonValue> FWidgetHandlers::AddWidget(const TSharedPtr<FJsonObject>&
 		}
 	}
 
-	// UE 5.4 exposed this map; UE 5.5 removed it from UWidgetBlueprint.
-#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION == 4
+	// #728: the WidgetBlueprintCompiler ensures every added widget has an entry in
+	// WidgetVariableNameToGuidMap (UMGEditor WidgetBlueprintCompiler.cpp: "Widget
+	// [X] was added but did not get a GUID"). The map was present in 5.4, absent
+	// in the 5.5-5.7 window, and present again in 5.8, so register the GUID on
+	// 5.4 and on 5.8+ (skipping the versions where the member does not exist).
+#if (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION == 4) || (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 8) || ENGINE_MAJOR_VERSION > 5
 	if (!WidgetBP->WidgetVariableNameToGuidMap.Contains(NewWidget->GetFName()))
 	{
 		WidgetBP->WidgetVariableNameToGuidMap.Add(NewWidget->GetFName(), FGuid::NewGuid());
@@ -906,6 +910,15 @@ TSharedPtr<FJsonValue> FWidgetHandlers::WrapRoot(const TSharedPtr<FJsonObject>&
 	WidgetBP->WidgetTree->RootWidget = Wrapper;
 	Wrapper->AddChild(OldRoot);
 
+	// #728: register the new wrapper's GUID so the WidgetBlueprintCompiler ensure
+	// does not fire (see add_widget). Same version window as there.
+#if (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION == 4) || (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION >= 8) || ENGINE_MAJOR_VERSION > 5
+	if (!WidgetBP->WidgetVariableNameToGuidMap.Contains(Wrapper->GetFName()))
+	{
+		WidgetBP->WidgetVariableNameToGuidMap.Add(Wrapper->GetFName(), FGuid::NewGuid());
+	}
+#endif
+
 	WidgetBP->MarkPackageDirty();
 	FKismetEditorUtilities::CompileBlueprint(WidgetBP);
 	UEditorAssetLibrary::SaveAsset(AssetPath);

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/UE_MCP_Bridge.Build.cs

@@ -62,6 +62,7 @@ public class UE_MCP_Bridge : ModuleRules
 				"Landscape",
 				"LevelEditor",
 				"LevelSequence",
+				"LevelSequenceEditor",
 				"MaterialEditor",
 				"MovieScene",
 				"MovieSceneTracks",
@@ -77,6 +78,7 @@ public class UE_MCP_Bridge : ModuleRules
 				"PropertyEditor",
 				"PythonScriptPlugin",
 				"Sequencer",
+				"Settings",
 				"Slate",
 				"SlateCore",
 				"StateTreeModule",

package/skills/ue-mcp-blueprint/SKILL.md

@@ -7,6 +7,19 @@ description: Use when authoring or modifying Unreal Blueprint assets through ue-
 
 The `blueprint` tool covers reading, authoring, and compiling Blueprints. The default workflow is **read → mutate → compile**, never fire-and-forget.
 
+## Authoring a graph body: prefer the Epic DSL (#711)
+
+When you are authoring the **contents of a graph** (event graph, function body, macro) - a set of nodes plus their wiring - do **not** default to node-by-node `add_node`/`connect_pins`. Reach for Epic's graph DSL first:
+
+1. `blueprint(action="epic_get_graph_dsl_docs")` - read the S-expression grammar once.
+2. `blueprint(action="epic_write_graph_dsl", ...)` - author + compile the whole graph body in one call.
+
+The DSL authors and compiles an entire graph in a single round-trip, which is materially faster and more reliable than stitching individual K2Nodes together (one correct pass vs several failed iterations). Use it for graph bodies whenever it is available.
+
+**Availability / fallback.** The `epic_*` actions come from Epic's ToolsetRegistry and require **UE 5.8+ with the Epic toolset plugins enabled**. Check with `epic(action="status")`. When they are unavailable (pre-5.8, or the registry is off), fall back to the native node path below.
+
+**Keep using the native actions for** read/discovery, SCS components, CDO/class defaults, interfaces + event dispatchers, structured `compile`/`validate`, and anything with no Epic equivalent - the native path adds idempotency and rollback the raw tools lack. See the `ue-mcp-epic-routing` skill for the full epic-vs-native decision.
+
 ## Discovery before authoring
 
 For any existing Blueprint:

package/skills/ue-mcp-epic-routing/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: ue-mcp-epic-routing
+description: Use when deciding between ue-mcp's native category actions and Epic's wrapped ToolsetRegistry tools (the `epic_*` actions, incl. the Blueprint graph DSL) for a task in Unreal. Pulls in when authoring Blueprint graph bodies, or any time both a native action and an epic_* action could do the job and you need to pick.
+---
+
+# Epic-vs-native tool routing (ue-mcp)
+
+ue-mcp exposes two overlapping surfaces. Picking the right one per task avoids slow, failure-prone paths.
+
+- **Native category actions** - `blueprint(...)`, `level(...)`, `material(...)`, etc. Hand-written, idempotent, with rollback and structured errors.
+- **Epic `epic_*` actions** - Epic's own MCP toolsets, surfaced in-category when the ToolsetRegistry is available (UE 5.8+ with the Epic toolset plugins enabled). Discover them with `epic(action="status")` and `epic(action="list_toolsets")`.
+
+This is **not** a blanket "always use epic" rule. Epic needs 5.8 + plugins, and much of ue-mcp has no epic equivalent or adds idempotency/rollback the raw tools lack.
+
+## The one that matters most: Blueprint graph bodies -> the DSL
+
+Authoring the **contents of a graph** (event graph, function body, macro) is the headline case.
+
+- Prefer `blueprint(action="epic_write_graph_dsl", ...)`. Call `blueprint(action="epic_get_graph_dsl_docs")` first to get the S-expression grammar.
+- It authors **and compiles the whole graph in one call** - materially faster and more reliable than node-by-node `add_node` + `connect_pins` (typically one correct pass instead of several failed iterations).
+
+## Decision table
+
+| Task | Route |
+|------|-------|
+| Author/replace a graph body (nodes + wiring) | `blueprint(epic_write_graph_dsl)` (docs first) |
+| Read / inspect a graph, list graphs/variables/functions | native `blueprint(read*, list_*, get_execution_flow)` |
+| SCS components, reparenting, component properties | native `blueprint(add_component, ...)` |
+| CDO / class defaults, tick settings | native `blueprint(set_class_default, set_actor_tick_settings)` |
+| Interfaces, event dispatchers | native `blueprint(create_interface, add_interface, add_event_dispatcher)` |
+| Structured compile / validate with diagnostics | native `blueprint(compile, validate)` |
+| A task with no native action but an `epic_*` one exists | the `epic_*` action |
+| A task with no epic equivalent | the native action |
+
+## Fallback
+
+If `epic(action="status")` reports the registry unavailable (pre-5.8, plugins off, or `available=false`), route **everything** through the native path - the DSL actions will not exist. The native node-by-node path (`add_node` -> `set_node_property` -> `connect_pins` -> `compile`) always works; see the `ue-mcp-blueprint` skill.