ue-mcp 1.2.3 → 1.3.0

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

@@ -4,6 +4,7 @@
 // stays in BlueprintHandlers.cpp::RegisterHandlers.
 
 #include "BlueprintHandlers.h"
+#include "BlueprintHandlers_Internal.h"
 #include "HandlerRegistry.h"
 #include "HandlerUtils.h"
 #include "Kismet2/BlueprintEditorUtils.h"
@@ -13,6 +14,10 @@
 #include "EdGraph/EdGraph.h"
 #include "EdGraph/EdGraphPin.h"
 #include "EdGraphSchema_K2.h"
+// #894: an animation layer override must be created as an AnimationGraph on
+// the animation schema, not as a K2 function graph.
+#include "AnimationGraph.h"
+#include "AnimationGraphSchema.h"
 #include "K2Node_FunctionEntry.h"
 #include "K2Node_EditablePinBase.h"
 #include "K2Node_CustomEvent.h"
@@ -94,7 +99,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::CreateFunction(const TSharedPtr<FJson
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Idempotency: existing function graph short-circuits.
@@ -223,7 +228,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ListBlueprintFunctions(const TSharedP
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Skeleton class super is the reliable parent during an in-editor edit; fall
@@ -556,7 +561,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::RenameFunction(const TSharedPtr<FJson
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the function graph
@@ -608,7 +613,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::DeleteFunction(const TSharedPtr<FJson
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* FoundGraph = nullptr;
@@ -726,7 +731,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::OverrideFunction(const TSharedPtr<FJs
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	const FName FuncName(*FunctionName);
@@ -850,12 +855,65 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::OverrideFunction(const TSharedPtr<FJs
 		return MCPResult(Result);
 	}
 
+	// #894: an animation layer override has to be an AnimationGraph. Creating a
+	// plain K2 function graph for one produces a graph the anim compiler never
+	// evaluates, so the override binds to nothing and the layer is inert while
+	// every read of the Blueprint says the override is there.
+	//
+	// The declaration is the authority on the graph's type, so mirror it rather
+	// than keeping a list of which functions happen to be layers: find the graph
+	// the override function was declared in and reuse its graph class and
+	// schema. One rule covers a layer declared on an Animation Layer Interface
+	// and one inherited from a parent Anim Blueprint, and it stays correct if
+	// Epic adds another graph-backed override kind.
+	//
+	// The predicate is deliberately the narrowest one that can be CHECKED
+	// rather than inferred. Both halves have to hold: the Blueprint answers
+	// SupportsAnimLayers (which only UAnimBlueprint does), and the graph that
+	// declared the function is a UAnimationGraph. Reading the declaration is
+	// stronger than testing the signature for a pose parameter, because it asks
+	// what the layer IS instead of what it looks like, and it cannot turn an
+	// ordinary function override on an Anim Blueprint into an animation graph.
+	//
+	// The cost of that narrowness is one case it does not cover: a layer
+	// declared on a native class has no declaring Blueprint graph to read, so
+	// it falls through to the K2 default. That is the false negative, and it is
+	// the right direction to be wrong in. Anim layers are authored on Animation
+	// Layer Interfaces and on parent Anim Blueprints, both of which are covered.
+	TSubclassOf<UEdGraph> GraphClass = UEdGraph::StaticClass();
+	TSubclassOf<UEdGraphSchema> SchemaClass = UEdGraphSchema_K2::StaticClass();
+	FString MirroredFromGraph;
+	if (Blueprint->SupportsAnimLayers())
+	{
+		if (UBlueprint* DeclaringBlueprint = UBlueprint::GetBlueprintFromClass(OverrideFuncClass))
+		{
+			for (UEdGraph* SourceGraph : DeclaringBlueprint->FunctionGraphs)
+			{
+				if (!SourceGraph || SourceGraph->GetFName() != FuncName) continue;
+				if (SourceGraph->IsA<UAnimationGraph>())
+				{
+					GraphClass = SourceGraph->GetClass();
+					MirroredFromGraph = SourceGraph->GetPathName();
+					if (UClass* SourceSchema = SourceGraph->Schema.Get())
+					{
+						SchemaClass = SourceSchema;
+					}
+					else
+					{
+						SchemaClass = UAnimationGraphSchema::StaticClass();
+					}
+				}
+				break;
+			}
+		}
+	}
+
 	// Function-form override: create the graph seeded from the override class so
 	// the entry/result terminators carry the base function's exact signature.
 	// (This is the fix for #688 - create_function produced a blank graph that
 	// never bound as the override.)
 	UEdGraph* NewGraph = FBlueprintEditorUtils::CreateNewGraph(
-		Blueprint, FuncName, UEdGraph::StaticClass(), UEdGraphSchema_K2::StaticClass());
+		Blueprint, FuncName, GraphClass, SchemaClass);
 	if (!NewGraph)
 	{
 		return MCPError(FString::Printf(TEXT("Failed to create override graph: %s"), *FunctionName));
@@ -863,6 +921,17 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::OverrideFunction(const TSharedPtr<FJs
 
 	FBlueprintEditorUtils::AddFunctionGraph<UClass>(Blueprint, NewGraph, /*bIsUserCreated=*/false, OverrideFuncClass);
 
+	// #894: creating the graph with the right class and schema is only half of
+	// it. CreateFunctionGraph gives an AnimationGraph its result node, but the
+	// layer's input pose nodes come from the interface function's own pose
+	// parameters, and only ConformAnimGraphToInterface seeds those. Without
+	// this the override is correctly typed and still unusable: an empty layer
+	// with nothing to plug a pose into.
+	if (!MirroredFromGraph.IsEmpty())
+	{
+		UAnimationGraphSchema::ConformAnimGraphToInterface(Blueprint, *NewGraph, OverrideFunc);
+	}
+
 	FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(Blueprint);
 	FKismetEditorUtilities::CompileBlueprint(Blueprint);
 	SaveAssetPackage(Blueprint);
@@ -875,6 +944,19 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::OverrideFunction(const TSharedPtr<FJs
 	Result->SetStringField(TEXT("graphName"), NewGraph->GetName());
 	Result->SetStringField(TEXT("sourceClass"), OverrideFuncClass->GetPathName());
 	Result->SetStringField(TEXT("source"), Source);
+	// #894: report the graph's actual type. An anim layer override that came
+	// back as an EdGraph on the K2 schema was the whole bug, and it was
+	// invisible from the response.
+	Result->SetStringField(TEXT("graphClass"), NewGraph->GetClass()->GetName());
+	if (UClass* AppliedSchema = NewGraph->Schema.Get())
+	{
+		Result->SetStringField(TEXT("schemaClass"), AppliedSchema->GetName());
+	}
+	if (!MirroredFromGraph.IsEmpty())
+	{
+		Result->SetBoolField(TEXT("animationGraph"), true);
+		Result->SetStringField(TEXT("mirroredFromGraph"), MirroredFromGraph);
+	}
 
 	TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
 	Payload->SetStringField(TEXT("path"), AssetPath);
@@ -896,7 +978,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ListOverridableFunctions(const TShare
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	FBlueprintEditorUtils::ConformImplementedInterfaces(Blueprint);

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

@@ -89,46 +89,6 @@ namespace
 			PinObj->SetStringField(TEXT("defaultObject"), Pin->DefaultObject->GetPathName());
 		}
 	}
-
-	FString MakeDefaultGraphDumpPath(const FString& AssetPath, const FString& GraphName)
-	{
-		const FString AssetName = FPackageName::GetLongPackageAssetName(AssetPath);
-		const FString PathHash = FString::Printf(TEXT("%08x"), GetTypeHash(AssetPath + TEXT(":") + GraphName));
-		const FString BaseName = FPaths::MakeValidFileName(AssetName + TEXT("_") + GraphName + TEXT("_") + PathHash);
-		return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("UE_MCP"), TEXT("GraphDumps"), BaseName + TEXT(".json"));
-	}
-
-	bool WriteJsonObjectToFile(const TSharedPtr<FJsonObject>& JsonObject, const FString& RequestedPath, const FString& AssetPath, const FString& GraphName, FString& OutResolvedPath, FString& OutError)
-	{
-		OutResolvedPath = RequestedPath.IsEmpty() ? MakeDefaultGraphDumpPath(AssetPath, GraphName) : RequestedPath;
-		if (FPaths::IsRelative(OutResolvedPath))
-		{
-			OutResolvedPath = FPaths::Combine(FPaths::ProjectSavedDir(), OutResolvedPath);
-		}
-
-		const FString Directory = FPaths::GetPath(OutResolvedPath);
-		if (!Directory.IsEmpty() && !IFileManager::Get().MakeDirectory(*Directory, true))
-		{
-			OutError = FString::Printf(TEXT("Failed to create dump directory: %s"), *Directory);
-			return false;
-		}
-
-		FString JsonText;
-		const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&JsonText);
-		if (!FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer))
-		{
-			OutError = TEXT("Failed to serialize graph JSON");
-			return false;
-		}
-
-		if (!FFileHelper::SaveStringToFile(JsonText, *OutResolvedPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
-		{
-			OutError = FString::Printf(TEXT("Failed to write graph dump: %s"), *OutResolvedPath);
-			return false;
-		}
-
-		return true;
-	}
 }
 
 
@@ -145,7 +105,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::AddNode(const TSharedPtr<FJsonObject>
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the target graph
@@ -184,6 +144,10 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::AddNode(const TSharedPtr<FJsonObject>
 	else if (NodeClass == TEXT("SwitchEnum"))   ResolvedClass = TEXT("K2Node_SwitchEnum");
 	else if (NodeClass == TEXT("SwitchString")) ResolvedClass = TEXT("K2Node_SwitchString");
 	else if (NodeClass == TEXT("MakeStruct"))   ResolvedClass = TEXT("K2Node_MakeStruct");
+	// #981: UMG "Create Widget". The literal K2Node_CreateWidget already
+	// resolved through the UEdGraphNode lookup below; this is the short form
+	// callers reach for first, matching every other alias here.
+	else if (NodeClass == TEXT("CreateWidget")) ResolvedClass = TEXT("K2Node_CreateWidget");
 	else if (NodeClass == TEXT("BreakStruct"))  ResolvedClass = TEXT("K2Node_BreakStruct");
 	else if (NodeClass == TEXT("MakeArray"))    ResolvedClass = TEXT("K2Node_MakeArray");
 	else if (NodeClass == TEXT("Return") || NodeClass == TEXT("FunctionResult")) ResolvedClass = TEXT("K2Node_FunctionResult");
@@ -815,7 +779,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ReadBlueprintGraph(const TSharedPtr<F
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the graph in UbergraphPages and FunctionGraphs
@@ -904,6 +868,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ReadBlueprintGraph(const TSharedPtr<F
 
 		auto Result = MCPSuccess();
 		Result->SetStringField(TEXT("path"), AssetPath);
+		AnnotateResolvedBlueprint(Result, Blueprint);
 		Result->SetStringField(TEXT("graphName"), GraphName);
 		Result->SetArrayField(TEXT("nodes"), Nodes);
 		Result->SetNumberField(TEXT("nodeCount"), Nodes.Num());
@@ -952,6 +917,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ReadBlueprintGraph(const TSharedPtr<F
 
 		auto Result = MCPSuccess();
 		Result->SetStringField(TEXT("path"), AssetPath);
+		AnnotateResolvedBlueprint(Result, Blueprint);
 		Result->SetStringField(TEXT("graphName"), GraphName);
 		Result->SetBoolField(TEXT("dumpedToFile"), true);
 		Result->SetStringField(TEXT("outputPath"), ResolvedDumpPath);
@@ -999,7 +965,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ConnectPins(const TSharedPtr<FJsonObj
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
@@ -1215,7 +1181,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::DeleteNode(const TSharedPtr<FJsonObje
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
@@ -1270,7 +1236,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetNodeProperty(const TSharedPtr<FJso
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
@@ -1681,7 +1647,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ExportNodesT3D(const TSharedPtr<FJson
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
@@ -1775,7 +1741,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ImportNodesT3D(const TSharedPtr<FJson
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
@@ -1923,7 +1889,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::CleanupGraph(const TSharedPtr<FJsonOb
 	if (auto Err = RequireStringAlt(Params, TEXT("path"), TEXT("assetPath"), AssetPath)) return Err;
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	const FString GraphName = OptionalString(Params, TEXT("graphName"));
 
@@ -1999,7 +1965,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ConnectPinsBatch(const TSharedPtr<FJs
 	}
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	UEdGraph* TargetGraph = FindGraph(Blueprint, GraphName);
 	if (!TargetGraph) return MCPError(FString::Printf(TEXT("Graph not found: %s"), *GraphName));
@@ -2104,7 +2070,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetNodePosition(const TSharedPtr<FJso
 	int32 PosY = OptionalInt(Params, TEXT("posY"), 0);
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 	UEdGraph* Graph = FindGraph(Blueprint, GraphName);
 	if (!Graph) return MCPError(FString::Printf(TEXT("Graph not found: %s"), *GraphName));
 	UEdGraphNode* Node = FindNodeByGuidOrName(Graph, NodeId);
@@ -2137,7 +2103,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::AutoLayoutGraph(const TSharedPtr<FJso
 	int32 RowGap = OptionalInt(Params, TEXT("rowGap"), 200);
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 	UEdGraph* Graph = FindGraph(Blueprint, GraphName);
 	if (!Graph) return MCPError(FString::Printf(TEXT("Graph not found: %s"), *GraphName));
 

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

@@ -5,10 +5,100 @@
 // plugin - no downstream code is expected to include this.
 
 #include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+#include "EdGraph/EdGraph.h"
+#include "HAL/FileManager.h"
+#include "Misc/FileHelper.h"
+#include "Misc/PackageName.h"
+#include "Misc/Paths.h"
+#include "Serialization/JsonSerializer.h"
+#include "Serialization/JsonWriter.h"
 
 class UBlueprint;
 class UActorComponent;
 
+// ── Graph selectors ─────────────────────────────────────────────────────────
+//
+// list_blueprint_graphs hands callers a `selector` they can pass back as
+// graphName, and duplicate names (AnimBP "Transition", "Locomotion") get an
+// index suffix. search_call_sites has to report the same selector for the same
+// graph or the two disagree about how to address one graph, so the rule lives
+// here rather than being restated per caller.
+
+/** "Locomotion" when the name is unique, "Locomotion[3]" when it is not. */
+inline FString MakeGraphSelector(const FString& Name, int32 DuplicateIndex, int32 DuplicateCount)
+{
+	return DuplicateCount > 1
+		? FString::Printf(TEXT("%s[%d]"), *Name, DuplicateIndex)
+		: Name;
+}
+
+/** How many graphs share each name, which is what decides whether a selector
+ *  needs its index suffix. */
+inline void CountGraphNames(const TArray<UEdGraph*>& Graphs, TMap<FString, int32>& OutNameCounts)
+{
+	for (UEdGraph* Graph : Graphs)
+	{
+		if (Graph)
+		{
+			++OutNameCounts.FindOrAdd(Graph->GetName());
+		}
+	}
+}
+
+// ── Graph dump files ────────────────────────────────────────────────────────
+//
+// read_graph writes an oversized result to a file under Saved/UE_MCP rather
+// than returning it inline. search_call_sites follows the same convention, so
+// both use the same path builder and the same writer.
+
+inline FString MakeDefaultGraphDumpPath(const FString& AssetPath, const FString& GraphName)
+{
+	const FString AssetName = FPackageName::GetLongPackageAssetName(AssetPath);
+	const FString PathHash = FString::Printf(TEXT("%08x"), GetTypeHash(AssetPath + TEXT(":") + GraphName));
+	const FString BaseName = FPaths::MakeValidFileName(AssetName + TEXT("_") + GraphName + TEXT("_") + PathHash);
+	return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("UE_MCP"), TEXT("GraphDumps"), BaseName + TEXT(".json"));
+}
+
+inline bool WriteJsonObjectToFile(
+	const TSharedPtr<FJsonObject>& JsonObject,
+	const FString& RequestedPath,
+	const FString& AssetPath,
+	const FString& GraphName,
+	FString& OutResolvedPath,
+	FString& OutError)
+{
+	OutResolvedPath = RequestedPath.IsEmpty() ? MakeDefaultGraphDumpPath(AssetPath, GraphName) : RequestedPath;
+	if (FPaths::IsRelative(OutResolvedPath))
+	{
+		OutResolvedPath = FPaths::Combine(FPaths::ProjectSavedDir(), OutResolvedPath);
+	}
+
+	const FString Directory = FPaths::GetPath(OutResolvedPath);
+	if (!Directory.IsEmpty() && !IFileManager::Get().MakeDirectory(*Directory, true))
+	{
+		OutError = FString::Printf(TEXT("Failed to create dump directory: %s"), *Directory);
+		return false;
+	}
+
+	FString JsonText;
+	const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&JsonText);
+	if (!FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer))
+	{
+		OutError = TEXT("Failed to serialize graph JSON");
+		return false;
+	}
+
+	if (!FFileHelper::SaveStringToFile(JsonText, *OutResolvedPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
+	{
+		OutError = FString::Printf(TEXT("Failed to write graph dump: %s"), *OutResolvedPath);
+		return false;
+	}
+
+	return true;
+}
+
 // Resolve the named component template on a blueprint, honouring inheritance.
 // See definition in BlueprintHandlers_Graph.cpp for the full contract (bForWrite
 // semantics, ICH-override creation on write, CDO fallback on read, etc.).
@@ -18,3 +108,20 @@ UActorComponent* ResolveComponentTemplate(
 	bool bForWrite,
 	bool& bOutIsInherited,
 	TArray<FString>& OutAvailable);
+
+// #942: a level script Blueprint is not an asset of its own. It lives inside
+// the map package at "<Map>.<Map>:PersistentLevel.<Map>", so every Blueprint
+// action handed the umap path a caller actually has answered "Blueprint not
+// found". FBlueprintHandlers::LoadBlueprint now resolves a World path to that
+// object; the two helpers below carry the shared reporting around it, so read,
+// list_graphs, read_graph and get_execution_flow behave identically.
+//
+// Builds the "not found" response for a failed Blueprint lookup. When the path
+// names a World whose level script has never been created, the message says so
+// and prints the object path, rather than claiming the Blueprint is missing.
+TSharedPtr<FJsonValue> BlueprintNotFoundError(const FString& AssetPath);
+
+// Record which object actually answered the request. A caller that passed a
+// umap path gets back the level script Blueprint's object path, so the alias it
+// used is visible rather than implied.
+void AnnotateResolvedBlueprint(const TSharedPtr<FJsonObject>& Result, UBlueprint* Blueprint);

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

@@ -58,7 +58,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetVariableProperties(const TSharedPt
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the variable
@@ -315,7 +315,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetComponentProperty(const TSharedPtr
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	bool bIsInherited = false;
@@ -531,7 +531,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetClassDefault(const TSharedPtr<FJso
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	UClass* GenClass = Blueprint->GeneratedClass;
@@ -660,7 +660,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::AddFunctionParameter(const TSharedPtr
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the function graph
@@ -845,7 +845,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetVariableDefault(const TSharedPtr<F
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
 	if (!Blueprint)
 	{
-		return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+		return BlueprintNotFoundError(AssetPath);
 	}
 
 	// Find the variable description
@@ -970,7 +970,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::ReadComponentProperties(const TShared
 	if (auto Err = RequireString(Params, TEXT("componentName"), ComponentName)) return Err;
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	bool bIsInherited = false;
 	TArray<FString> Available;
@@ -1080,7 +1080,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::GetComponentProperty(const TSharedPtr
 	if (auto Err = RequireString(Params, TEXT("propertyName"), PropertyName)) return Err;
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	bool bIsInherited = false;
 	TArray<FString> Available;
@@ -1354,7 +1354,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetComponentOverrideMaterials(const T
 	}
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	bool bIsInherited = false;
 	TArray<FString> Available;
@@ -1444,7 +1444,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::AddTimelineTrack(const TSharedPtr<FJs
 	const FString TrackType = OptionalString(Params, TEXT("trackType"), TEXT("float")).ToLower();
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	// Find or create the UTimelineTemplate that backs the K2Node_Timeline.
 	const FName TimelineFName(*TimelineName);
@@ -1620,7 +1620,7 @@ TSharedPtr<FJsonValue> FBlueprintHandlers::SetCapsuleSize(const TSharedPtr<FJson
 	}
 
 	UBlueprint* Blueprint = LoadBlueprint(AssetPath);
-	if (!Blueprint) return MCPError(FString::Printf(TEXT("Blueprint not found: %s"), *AssetPath));
+	if (!Blueprint) return BlueprintNotFoundError(AssetPath);
 
 	bool bIsInherited = false;
 	TArray<FString> Available;