ue-mcp 1.2.3 → 1.3.0

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

@@ -54,6 +54,10 @@ private:
 	static TSharedPtr<FJsonValue> DeleteVariable(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> AddFunctionParameter(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> SetVariableDefault(const TSharedPtr<FJsonObject>& Params);
+	// #902: read the RESOLVED default off the generated class CDO, so a
+	// write-compile-readback loop can verify itself. Reports whether that value
+	// has reached the package as well as what it is (#931).
+	static TSharedPtr<FJsonValue> GetVariableDefault(const TSharedPtr<FJsonObject>& Params);
 
 	// v0.7.8 - agent-ergonomics additions (stubs)
 	static TSharedPtr<FJsonValue> ReadBlueprintGraphSummary(const TSharedPtr<FJsonObject>& Params);
@@ -83,6 +87,7 @@ private:
 	static TSharedPtr<FJsonValue> ReparentBlueprint(const TSharedPtr<FJsonObject>& Params);
 	// #580 flush orphaned InheritableComponentHandler override records
 	static TSharedPtr<FJsonValue> FlushInheritableComponentHandler(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> FlushComponentTemplates(const TSharedPtr<FJsonObject>& Params);
 
 	// issues #182/#183: C++ class CDO property access
 	static TSharedPtr<FJsonValue> SetCdoProperty(const TSharedPtr<FJsonObject>& Params);
@@ -97,6 +102,11 @@ private:
 	static TSharedPtr<FJsonValue> ConnectPinsBatch(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> SetNodePosition(const TSharedPtr<FJsonObject>& Params);
 	static TSharedPtr<FJsonValue> AutoLayoutGraph(const TSharedPtr<FJsonObject>& Params);
+	// #945: project-wide search for authored function call sites, narrowed by
+	// the Asset Registry before any package is loaded. Defined in
+	// BlueprintHandlers_Search.cpp.
+	static TSharedPtr<FJsonValue> SearchCallSites(const TSharedPtr<FJsonObject>& Params);
+
 	// #419: SetCapsuleSize on CapsuleComponent BP templates (UFUNCTION setter
 	// path; raw property writes leave the visualizer stale)
 	static TSharedPtr<FJsonValue> SetCapsuleSize(const TSharedPtr<FJsonObject>& Params);

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

@@ -0,0 +1,502 @@
+// Effective collision reads (#925). See BlueprintHandlers_Collision.h for why
+// the existing property dumps cannot answer the question these two do.
+//
+// The whole file reads. Nothing here writes a package, spawns anything, or
+// touches the open level.
+
+#include "BlueprintHandlers_Collision.h"
+
+#include "BlueprintHandlers_Internal.h"
+#include "HandlerRegistry.h"
+#include "HandlerUtils.h"
+
+#include "Components/PrimitiveComponent.h"
+#include "Engine/Blueprint.h"
+#include "Engine/CollisionProfile.h"
+#include "Engine/EngineTypes.h"
+#include "GameFramework/Actor.h"
+
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+
+namespace
+{
+// The container has one byte per serialisable channel and ECC_GameTraceChannel50
+// is the last of them, so the response table is exactly this wide. ECC_MAX is
+// larger because it counts the deprecated non-serialised entry past the end.
+constexpr int32 CollisionChannelCount = 64;
+
+/** "Block" rather than "ECR_Block". The enum's DisplayName metadata says the
+ *  same thing, but only in an editor build with metadata loaded, and a result
+ *  field that silently degrades to an ordinal is worse than a switch. */
+const TCHAR* CollisionResponseName(ECollisionResponse Response)
+{
+	switch (Response)
+	{
+	case ECR_Ignore:  return TEXT("Ignore");
+	case ECR_Overlap: return TEXT("Overlap");
+	case ECR_Block:   return TEXT("Block");
+	default:          return TEXT("Unknown");
+	}
+}
+
+/** The spelling the Collision details panel uses, for the same reason. */
+const TCHAR* CollisionEnabledName(ECollisionEnabled::Type Enabled)
+{
+	switch (Enabled)
+	{
+	case ECollisionEnabled::NoCollision:      return TEXT("NoCollision");
+	case ECollisionEnabled::QueryOnly:        return TEXT("QueryOnly");
+	case ECollisionEnabled::PhysicsOnly:      return TEXT("PhysicsOnly");
+	case ECollisionEnabled::QueryAndPhysics:  return TEXT("QueryAndPhysics");
+	case ECollisionEnabled::ProbeOnly:        return TEXT("ProbeOnly");
+	case ECollisionEnabled::QueryAndProbe:    return TEXT("QueryAndProbe");
+	default:                                  return TEXT("Unknown");
+	}
+}
+
+/** The C++ enumerator for a container index: ECC_Camera for 4. Stable across
+ *  projects, unlike the display name, so a caller can key on it. */
+FString CollisionChannelEnumName(int32 Index)
+{
+	if (Index >= 0 && Index < 8)
+	{
+		static const TCHAR* const Fixed[8] = {
+			TEXT("ECC_WorldStatic"), TEXT("ECC_WorldDynamic"), TEXT("ECC_Pawn"),
+			TEXT("ECC_Visibility"),  TEXT("ECC_Camera"),       TEXT("ECC_PhysicsBody"),
+			TEXT("ECC_Vehicle"),     TEXT("ECC_Destructible")
+		};
+		return Fixed[Index];
+	}
+	if (Index >= 8 && Index < 14)
+	{
+		return FString::Printf(TEXT("ECC_EngineTraceChannel%d"), Index - 7);
+	}
+	if (Index >= 14 && Index < CollisionChannelCount)
+	{
+		return FString::Printf(TEXT("ECC_GameTraceChannel%d"), Index - 13);
+	}
+	return FString::Printf(TEXT("ECC_Unknown%d"), Index);
+}
+
+/** The name a channel carries when the project has not renamed it. Comparing
+ *  the configured name against this is what tells a project's own channel
+ *  ("Weapon") apart from an unused slot ("GameTraceChannel7"). */
+FString CollisionChannelDefaultName(int32 Index)
+{
+	FString EnumName = CollisionChannelEnumName(Index);
+	EnumName.RemoveFromStart(TEXT("ECC_"));
+	return EnumName;
+}
+
+/** One channel, described once so the component read and the profile read
+ *  cannot disagree about what a channel is called. */
+struct FMCPCollisionChannelInfo
+{
+	int32 Index = 0;
+	ECollisionChannel Channel = ECC_WorldStatic;
+	FString EnumName;
+	FString DisplayName;
+	bool bCustomNamed = false;
+	bool bTraceChannel = false;
+	bool bObjectChannel = false;
+};
+
+/** Build the channel table from the project's own collision settings, so a
+ *  custom trace or object channel appears under the name the project gave it
+ *  rather than as GameTraceChannel<n>. */
+TArray<FMCPCollisionChannelInfo> BuildCollisionChannelTable()
+{
+	TArray<FMCPCollisionChannelInfo> Table;
+
+	UCollisionProfile* Profile = UCollisionProfile::Get();
+	Table.Reserve(CollisionChannelCount);
+	for (int32 Index = 0; Index < CollisionChannelCount; ++Index)
+	{
+		FMCPCollisionChannelInfo Info;
+		Info.Index = Index;
+		Info.Channel = static_cast<ECollisionChannel>(Index);
+		Info.EnumName = CollisionChannelEnumName(Index);
+
+		const FString DefaultName = CollisionChannelDefaultName(Index);
+		Info.DisplayName = DefaultName;
+		if (Profile)
+		{
+			const FName Configured = Profile->ReturnChannelNameFromContainerIndex(Index);
+			if (!Configured.IsNone())
+			{
+				Info.DisplayName = Configured.ToString();
+			}
+			Info.bTraceChannel = Profile->ConvertToTraceType(Info.Channel) != TraceTypeQuery_MAX;
+			Info.bObjectChannel = Profile->ConvertToObjectType(Info.Channel) != ObjectTypeQuery_MAX;
+		}
+		Info.bCustomNamed = !Info.DisplayName.Equals(DefaultName, ESearchCase::CaseSensitive);
+		Table.Add(Info);
+	}
+	return Table;
+}
+
+/** Which channels a response list carries by default.
+ *
+ *  All 64 would bury the answer in fifty unused GameTraceChannel slots, so the
+ *  default is the eight engine channels every project has plus every channel
+ *  the project actually configured. includeAllChannels=true asks for the rest. */
+bool ShouldReportChannel(const FMCPCollisionChannelInfo& Info, bool bIncludeAll)
+{
+	if (bIncludeAll) return true;
+	if (Info.Index < 8) return true;
+	return Info.bCustomNamed;
+}
+
+/** Match a caller's `channel` argument against the table. Accepts the
+ *  configured display name ("Weapon"), the C++ enumerator ("ECC_Camera"), the
+ *  bare enumerator ("Camera") and the container index as a string. Returns
+ *  INDEX_NONE on a miss. */
+int32 FindCollisionChannel(const TArray<FMCPCollisionChannelInfo>& Table, const FString& Spec)
+{
+	if (Spec.IsEmpty()) return INDEX_NONE;
+
+	if (Spec.IsNumeric())
+	{
+		const int32 AsIndex = FCString::Atoi(*Spec);
+		return (AsIndex >= 0 && AsIndex < Table.Num()) ? AsIndex : INDEX_NONE;
+	}
+
+	for (const FMCPCollisionChannelInfo& Info : Table)
+	{
+		if (Info.DisplayName.Equals(Spec, ESearchCase::IgnoreCase)) return Info.Index;
+		if (Info.EnumName.Equals(Spec, ESearchCase::IgnoreCase)) return Info.Index;
+	}
+	return INDEX_NONE;
+}
+
+/** The names a failed channel lookup should suggest: everything a caller could
+ *  legitimately have meant, without the unused slots. */
+FString DescribeKnownChannels(const TArray<FMCPCollisionChannelInfo>& Table)
+{
+	TArray<FString> Names;
+	for (const FMCPCollisionChannelInfo& Info : Table)
+	{
+		if (ShouldReportChannel(Info, /*bIncludeAll=*/false))
+		{
+			Names.Add(Info.DisplayName);
+		}
+	}
+	return FString::Join(Names, TEXT(", "));
+}
+
+void WriteChannelIdentity(const TSharedPtr<FJsonObject>& Out, const FMCPCollisionChannelInfo& Info)
+{
+	Out->SetStringField(TEXT("channel"), Info.DisplayName);
+	Out->SetStringField(TEXT("enumName"), Info.EnumName);
+	Out->SetNumberField(TEXT("channelIndex"), Info.Index);
+	Out->SetBoolField(TEXT("isTraceChannel"), Info.bTraceChannel);
+	Out->SetBoolField(TEXT("isObjectChannel"), Info.bObjectChannel);
+	Out->SetBoolField(TEXT("isCustomNamed"), Info.bCustomNamed);
+}
+
+/** Look a profile up by name, tolerating a renamed profile through the
+ *  engine's own redirect table. */
+bool LookUpProfileTemplate(const FString& ProfileName, FCollisionResponseTemplate& OutTemplate, FString& OutResolvedName)
+{
+	OutResolvedName = ProfileName;
+	UCollisionProfile* Profile = UCollisionProfile::Get();
+	if (!Profile) return false;
+
+	FName Name(*ProfileName);
+	if (const FName* Redirect = Profile->LookForProfileRedirect(Name))
+	{
+		Name = *Redirect;
+		OutResolvedName = Name.ToString();
+	}
+	return Profile->GetProfileTemplate(Name, OutTemplate);
+}
+
+/** Every profile the project has, for a lookup that missed. */
+TArray<FString> ListProfileNames()
+{
+	TArray<FString> Names;
+	UCollisionProfile* Profile = UCollisionProfile::Get();
+	if (!Profile) return Names;
+	for (int32 Index = 0; Index < Profile->GetNumOfProfiles(); ++Index)
+	{
+		if (const FCollisionResponseTemplate* Template = Profile->GetProfileByIndex(Index))
+		{
+			Names.AddUnique(Template->Name.ToString());
+		}
+	}
+	return Names;
+}
+
+/** Collect every component on an Actor CDO, which is where a native C++
+ *  constructor's CreateDefaultSubobject lands. This is the case #925 was
+ *  reported from: verifying that a rebuilt constructor's
+ *  SetCollisionResponseToChannel actually reached the CDO. */
+UActorComponent* FindComponentOnActorCDO(
+	AActor* CDO,
+	const FString& ComponentName,
+	TArray<FString>& OutAvailable)
+{
+	if (!CDO) return nullptr;
+
+	UActorComponent* Found = nullptr;
+	for (UActorComponent* Component : CDO->GetComponents())
+	{
+		if (!Component) continue;
+		const FString Name = Component->GetName();
+		OutAvailable.AddUnique(Name);
+		if (!Found && Name.Equals(ComponentName, ESearchCase::IgnoreCase))
+		{
+			Found = Component;
+		}
+	}
+	return Found;
+}
+}
+
+void FCollisionQueryHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	Registry.RegisterHandler(TEXT("get_component_collision"), &GetComponentCollision);
+	Registry.RegisterHandler(TEXT("resolve_collision_profile"), &ResolveCollisionProfile);
+}
+
+TSharedPtr<FJsonValue> FCollisionQueryHandlers::GetComponentCollision(const TSharedPtr<FJsonObject>& Params)
+{
+	FString AssetPath;
+	if (auto Err = RequireStringAlt(Params, TEXT("assetPath"), TEXT("path"), AssetPath)) return Err;
+
+	FString ComponentName;
+	if (auto Err = RequireString(Params, TEXT("componentName"), ComponentName)) return Err;
+
+	const FString RequestedChannel = OptionalString(Params, TEXT("channel"));
+	const bool bIncludeAll = OptionalBool(Params, TEXT("includeAllChannels"), false);
+
+	// Two ways in, because the two things a caller wants to verify live in
+	// different places: a Blueprint's component template, and a native class's
+	// CDO component. A Blueprint path resolves as an asset; anything else is
+	// tried as a class.
+	UActorComponent* Component = nullptr;
+	TArray<FString> Available;
+	bool bInherited = false;
+	FString Source;
+	FString OwnerPath;
+
+	if (UBlueprint* Blueprint = Cast<UBlueprint>(MCPLoadAssetObject(AssetPath)))
+	{
+		Component = ResolveComponentTemplate(
+			Blueprint, ComponentName, /*bForWrite=*/false, bInherited, Available);
+		Source = TEXT("blueprint");
+		OwnerPath = Blueprint->GetPathName();
+	}
+	else
+	{
+		UClass* Class = MCPResolveClass(AssetPath);
+		if (!Class)
+		{
+			return MCPClassNotFoundError(AssetPath, TEXT("assetPath"));
+		}
+		if (!Class->IsChildOf(AActor::StaticClass()))
+		{
+			return MCPClassUnusableError(AssetPath, Class, TEXT("wrong_base"),
+				TEXT("it is not an Actor class, so it has no component to read collision from."));
+		}
+		AActor* CDO = Cast<AActor>(Class->GetDefaultObject());
+		Component = FindComponentOnActorCDO(CDO, ComponentName, Available);
+		Source = TEXT("class");
+		OwnerPath = Class->GetPathName();
+	}
+
+	if (!Component)
+	{
+		Available.Sort([](const FString& A, const FString& B) { return A < B; });
+		return MCPError(FString::Printf(
+			TEXT("Component '%s' not found on '%s'. Available: [%s]"),
+			*ComponentName, *AssetPath, *FString::Join(Available, TEXT(", "))));
+	}
+
+	UPrimitiveComponent* Primitive = Cast<UPrimitiveComponent>(Component);
+	if (!Primitive)
+	{
+		// A SceneComponent or a bare ActorComponent has no BodyInstance at all,
+		// and saying "not a PrimitiveComponent" is the difference between an
+		// answerable question and an empty response.
+		return MCPError(FString::Printf(
+			TEXT("Component '%s' on '%s' is a %s, which carries no collision. Only PrimitiveComponent ")
+				TEXT("subclasses (capsules, boxes, spheres, meshes) have a collision profile and per-channel responses."),
+			*ComponentName, *AssetPath, *Component->GetClass()->GetName()));
+	}
+
+	const TArray<FMCPCollisionChannelInfo> Table = BuildCollisionChannelTable();
+
+	int32 SingleChannel = INDEX_NONE;
+	if (!RequestedChannel.IsEmpty())
+	{
+		SingleChannel = FindCollisionChannel(Table, RequestedChannel);
+		if (SingleChannel == INDEX_NONE)
+		{
+			return MCPError(FString::Printf(
+				TEXT("Unknown collision channel '%s'. Pass a configured channel name, a C++ enumerator ")
+					TEXT("(ECC_Camera), or a container index. Known channels: %s"),
+				*RequestedChannel, *DescribeKnownChannels(Table)));
+		}
+	}
+
+	const FName ProfileName = Primitive->GetCollisionProfileName();
+	FCollisionResponseTemplate ProfileTemplate;
+	FString ResolvedProfileName;
+	const bool bProfileResolved =
+		LookUpProfileTemplate(ProfileName.ToString(), ProfileTemplate, ResolvedProfileName);
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("assetPath"), AssetPath);
+	Result->SetStringField(TEXT("resolvedPath"), OwnerPath);
+	Result->SetStringField(TEXT("source"), Source);
+	Result->SetStringField(TEXT("componentName"), Component->GetName());
+	Result->SetStringField(TEXT("componentClass"), Component->GetClass()->GetName());
+	Result->SetBoolField(TEXT("inherited"), bInherited);
+
+	Result->SetStringField(TEXT("collisionEnabled"), CollisionEnabledName(Primitive->GetCollisionEnabled()));
+	Result->SetBoolField(TEXT("collisionEnabledForQueries"), Primitive->IsQueryCollisionEnabled());
+	Result->SetBoolField(TEXT("collisionEnabledForPhysics"), Primitive->IsPhysicsCollisionEnabled());
+
+	const ECollisionChannel ObjectType = Primitive->GetCollisionObjectType();
+	const int32 ObjectTypeIndex = static_cast<int32>(ObjectType);
+	Result->SetStringField(TEXT("objectType"),
+		Table.IsValidIndex(ObjectTypeIndex) ? Table[ObjectTypeIndex].DisplayName : CollisionChannelEnumName(ObjectTypeIndex));
+	Result->SetStringField(TEXT("objectTypeEnumName"), CollisionChannelEnumName(ObjectTypeIndex));
+	Result->SetNumberField(TEXT("objectTypeIndex"), ObjectTypeIndex);
+
+	Result->SetStringField(TEXT("profileName"), ProfileName.ToString());
+	Result->SetBoolField(TEXT("profileResolved"), bProfileResolved);
+	if (bProfileResolved && !ResolvedProfileName.Equals(ProfileName.ToString(), ESearchCase::CaseSensitive))
+	{
+		Result->SetStringField(TEXT("profileRedirectedTo"), ResolvedProfileName);
+	}
+
+	// The effective response per channel. GetCollisionResponseToChannel is the
+	// evaluated answer: the profile's response with the component's own
+	// overrides already folded in. The profile's own response rides alongside
+	// so a caller can see WHERE the answer came from, which is what the
+	// ResponseArray text dump could never show for an inherited response.
+	TArray<TSharedPtr<FJsonValue>> Responses;
+	for (const FMCPCollisionChannelInfo& Info : Table)
+	{
+		if (SingleChannel != INDEX_NONE && Info.Index != SingleChannel) continue;
+		if (SingleChannel == INDEX_NONE && !ShouldReportChannel(Info, bIncludeAll)) continue;
+
+		const ECollisionResponse Effective = Primitive->GetCollisionResponseToChannel(Info.Channel);
+
+		TSharedPtr<FJsonObject> Entry = MakeShared<FJsonObject>();
+		WriteChannelIdentity(Entry, Info);
+		Entry->SetStringField(TEXT("response"), CollisionResponseName(Effective));
+		if (bProfileResolved)
+		{
+			const ECollisionResponse FromProfile = ProfileTemplate.ResponseToChannels.GetResponse(Info.Channel);
+			Entry->SetStringField(TEXT("profileResponse"), CollisionResponseName(FromProfile));
+			Entry->SetBoolField(TEXT("overridesProfile"), Effective != FromProfile);
+		}
+		Responses.Add(MakeShared<FJsonValueObject>(Entry));
+	}
+
+	if (SingleChannel != INDEX_NONE && Responses.Num() > 0)
+	{
+		// One channel asked for, one answer at the top level as well as in the
+		// list, so the caller does not have to index into an array of one.
+		Result->SetObjectField(TEXT("channel"), Responses[0]->AsObject());
+	}
+	Result->SetArrayField(TEXT("responses"), Responses);
+	Result->SetNumberField(TEXT("responseCount"), Responses.Num());
+	Result->SetBoolField(TEXT("includeAllChannels"), bIncludeAll);
+	return MCPResult(Result);
+}
+
+TSharedPtr<FJsonValue> FCollisionQueryHandlers::ResolveCollisionProfile(const TSharedPtr<FJsonObject>& Params)
+{
+	FString ProfileName;
+	if (auto Err = RequireString(Params, TEXT("profileName"), ProfileName)) return Err;
+
+	const FString RequestedChannel = OptionalString(Params, TEXT("channel"));
+	const bool bIncludeAll = OptionalBool(Params, TEXT("includeAllChannels"), false);
+
+	if (!UCollisionProfile::Get())
+	{
+		return MCPError(TEXT("Collision settings are not available in this process."));
+	}
+
+	FCollisionResponseTemplate Template;
+	FString ResolvedProfileName;
+	if (!LookUpProfileTemplate(ProfileName, Template, ResolvedProfileName))
+	{
+		TArray<FString> Known = ListProfileNames();
+		Known.Sort([](const FString& A, const FString& B) { return A < B; });
+
+		TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+		Obj->SetBoolField(TEXT("success"), false);
+		Obj->SetStringField(TEXT("error"), FString::Printf(
+			TEXT("No collision profile named '%s'. The project defines: %s"),
+			*ProfileName, *FString::Join(Known, TEXT(", "))));
+		Obj->SetStringField(TEXT("profileName"), ProfileName);
+		Obj->SetStringField(TEXT("reason"), TEXT("profile_not_found"));
+		TArray<TSharedPtr<FJsonValue>> KnownJson;
+		for (const FString& Name : Known) KnownJson.Add(MakeShared<FJsonValueString>(Name));
+		Obj->SetArrayField(TEXT("knownProfiles"), KnownJson);
+		return MakeShared<FJsonValueObject>(Obj);
+	}
+
+	const TArray<FMCPCollisionChannelInfo> Table = BuildCollisionChannelTable();
+
+	int32 SingleChannel = INDEX_NONE;
+	if (!RequestedChannel.IsEmpty())
+	{
+		SingleChannel = FindCollisionChannel(Table, RequestedChannel);
+		if (SingleChannel == INDEX_NONE)
+		{
+			return MCPError(FString::Printf(
+				TEXT("Unknown collision channel '%s'. Pass a configured channel name, a C++ enumerator ")
+					TEXT("(ECC_Camera), or a container index. Known channels: %s"),
+				*RequestedChannel, *DescribeKnownChannels(Table)));
+		}
+	}
+
+	auto Result = MCPSuccess();
+	Result->SetStringField(TEXT("profileName"), Template.Name.ToString());
+	Result->SetStringField(TEXT("requestedProfileName"), ProfileName);
+	if (!ResolvedProfileName.Equals(ProfileName, ESearchCase::CaseSensitive))
+	{
+		Result->SetStringField(TEXT("profileRedirectedTo"), ResolvedProfileName);
+	}
+	Result->SetStringField(TEXT("collisionEnabled"), CollisionEnabledName(Template.CollisionEnabled));
+
+	const int32 ObjectTypeIndex = static_cast<int32>(Template.ObjectType.GetValue());
+	Result->SetStringField(TEXT("objectType"),
+		Table.IsValidIndex(ObjectTypeIndex) ? Table[ObjectTypeIndex].DisplayName : CollisionChannelEnumName(ObjectTypeIndex));
+	Result->SetStringField(TEXT("objectTypeEnumName"), CollisionChannelEnumName(ObjectTypeIndex));
+	Result->SetStringField(TEXT("objectTypeName"), Template.ObjectTypeName.ToString());
+	Result->SetNumberField(TEXT("objectTypeIndex"), ObjectTypeIndex);
+	Result->SetBoolField(TEXT("canModify"), Template.bCanModify);
+#if WITH_EDITORONLY_DATA
+	Result->SetStringField(TEXT("helpMessage"), Template.HelpMessage);
+#endif
+
+	TArray<TSharedPtr<FJsonValue>> Responses;
+	for (const FMCPCollisionChannelInfo& Info : Table)
+	{
+		if (SingleChannel != INDEX_NONE && Info.Index != SingleChannel) continue;
+		if (SingleChannel == INDEX_NONE && !ShouldReportChannel(Info, bIncludeAll)) continue;
+
+		TSharedPtr<FJsonObject> Entry = MakeShared<FJsonObject>();
+		WriteChannelIdentity(Entry, Info);
+		Entry->SetStringField(TEXT("response"),
+			CollisionResponseName(Template.ResponseToChannels.GetResponse(Info.Channel)));
+		Responses.Add(MakeShared<FJsonValueObject>(Entry));
+	}
+
+	if (SingleChannel != INDEX_NONE && Responses.Num() > 0)
+	{
+		Result->SetObjectField(TEXT("channel"), Responses[0]->AsObject());
+	}
+	Result->SetArrayField(TEXT("responses"), Responses);
+	Result->SetNumberField(TEXT("responseCount"), Responses.Num());
+	Result->SetBoolField(TEXT("includeAllChannels"), bIncludeAll);
+	return MCPResult(Result);
+}

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+
+/**
+ * Effective collision reads (#925).
+ *
+ * What already existed reports the collision a component STORES, not the
+ * collision it HAS. blueprint(read_component_properties) exports BodyInstance
+ * as text, and that text carries CollisionProfileName plus the ResponseArray of
+ * overrides that DIFFER from the profile. A response inherited from the profile
+ * (the Pawn profile blocking Camera, say) appears nowhere in it, so "does this
+ * capsule block ECC_Camera" could not be answered from the dump.
+ * editor(get_object_properties) has the same limit: it exports property text,
+ * it does not evaluate the profile.
+ *
+ * That gap has teeth. A live-coded constructor change to
+ * SetCollisionResponseToChannel(ECC_Camera, ECR_Ignore) LOOKED applied, because
+ * the Live Coding compile succeeded, and the CDO still answered ECR_BLOCK until
+ * a proper on-disk build and an editor restart. The text dump was byte for byte
+ * identical before and after. Only the effective response, which is what
+ * UPrimitiveComponent::GetCollisionResponseToChannel returns, showed it.
+ *
+ * A separate class rather than another FBlueprintHandlers partition, because
+ * these register themselves and the two actions land in two different wire
+ * categories (`blueprint` and `project`) while sharing one channel table. The
+ * actions still read as blueprint(get_component_collision) and
+ * project(resolve_collision_profile) to a caller.
+ */
+class FCollisionQueryHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	/** Resolved collision state of one component template or CDO component. */
+	static TSharedPtr<FJsonValue> GetComponentCollision(const TSharedPtr<FJsonObject>& Params);
+
+	/** Per-channel responses of one named collision profile. */
+	static TSharedPtr<FJsonValue> ResolveCollisionProfile(const TSharedPtr<FJsonObject>& Params);
+};