Niagara: full stack-input authoring + graph introspection loop

Brings the Niagara MCP surface to parity with what the editor UI actually
lets you do. You can now read, mutate, and replicate any module input
binding at any nesting depth without guessing engine API or hardcoded
asset paths — and the same 96 commands work from Python MCP, Go CLI, or
direct C++ dispatcher.

Graph introspection (new NiagaraGraphIntrospection.cpp)
- get_niagara_graph_nodes: list every node with verbosity control
  (summary / connections / full) + type_filter + name_filter. Three
  resolver modes: scratch pad (system+module), emitter stack graph
  (system+emitter+script_usage), or standalone script asset.
- get_niagara_node_info: deep single-node inspect by index/class/GUID
  with pin layout, connections, and node-type-specific fields
  (op_name, function_script, hlsl_preview, input_name/type).
- trace_niagara_connection: BFS upstream/downstream with pin_name filter.
- validate_niagara_graph: orphan/dead-end/missing-input classifier,
  skips +Add placeholder pins so no false positives.

Scratch pad apply + script properties (new NiagaraScratchPadApply.cpp)
- apply_niagara_scratch_pad / apply_and_save_niagara_scratch_pad wrap
  FNiagaraScratchPadScriptViewModel::ApplyChanges[AndSave] — the actual
  Apply / Apply & Save buttons.
- get/set_niagara_script_properties covers every
  FVersionedNiagaraScriptData field including TArray<FName>
  (ProvidedDependencies) and TArray<FNiagaraModuleDependency>
  (RequiredDependencies). Explicit per-FProperty-type reader avoids
  an FText reflection crash the generic walker used to hit.

Script parameters + node creation (new NiagaraScriptParams.cpp)
- list/add/remove/rename_niagara_script_parameter with automatic
  cascade to Map Get / Map Set pins on remove. Output-param adds
  dispatch PostEditChangeProperty on the Output node so the canvas
  refreshes immediately instead of needing a name-field tickle.
- add_niagara_graph_node supports Op, FunctionCall, DataInterfaceFunction,
  ParameterMapGet, ParameterMapSet, Reroute, Input. DI member functions
  (array.Length etc) use UNiagaraDataInterface::GetFunctionSignatures
  and set UNiagaraNodeFunctionCall::Signature directly — FunctionScript
  stays null, same as the editor's right-click "Functions" submenu.
- delete_niagara_graph_node by index or GUID, mirrors on asset + edit-copy.

Stack input binding loop (new NiagaraStackBinding.cpp)
- get_niagara_module_input_binding resolves Default / Local / Linked /
  Dynamic / Data / Expression mode for every input and recurses into
  dynamic-input children. One call returns the full tree — no separate
  walk of override pins.
- clear_niagara_module_input resets any input to default, top-level or
  nested via dot-path (e.g. "Spawn Count.Position Array"). Replicates
  FNiagaraStackGraphUtilities::RemoveNodesForStackFunctionInputOverridePin
  (non-exported) using exported primitives.
- list_niagara_input_source_menu reproduces the stack-UI source dropdown —
  all DynamicInput-usage scripts from AssetRegistry plus scratch-pad DIs
  on the same system (tagged source: "scratch_pad"), plus link parameters
  from Engine / Particles / User namespaces via FNiagaraConstants.

Stack discovery + reverse lookup (new NiagaraStackDiscovery.cpp)
- find_niagara_scratch_pad_usage scans every system + emitter stack graph
  for FunctionCall nodes referencing a scratch pad, so you can answer
  "what uses this DI?" in one call.
- resolve_niagara_built_in_dynamic_input replaces hardcoded engine paths
  (/Niagara/Modules/DynamicInputs/UniformRangedFloat — which moves
  between UE versions) with live AssetRegistry scan.
- list_niagara_data_interface_functions enumerates DI member functions
  via UNiagaraDataInterface::GetFunctionSignatures so the AI can pick a
  real function_name before spawning a DataInterfaceFunction node.

Nested path resolver (new NiagaraStackPathResolver.h)
- Shared DescendNestedPath helper walks a dot-path like
  "Spawn Count.Position Array" through dynamic-input function-call chains.
- Wired into set_niagara_dynamic_input, link_niagara_parameter, and
  set_niagara_module_input so every setter now accepts arbitrary nesting.

Nested literal setter
- set_niagara_module_input on a dot-path routes to
  GetOrCreateStackFunctionInputOverridePin + DefaultValue write, the
  actual path the editor uses for local values. Top-level inputs whose
  source is parameter_map_input auto-delegate to the rapid-iteration
  setter so you don't get "input not found" errors for Module.* aliased
  inputs like SpawnPerFrame's Spawn Probability.

Dynamic input template resolution
- set_niagara_dynamic_input for random_range / uniform_random types now
  falls back to FNiagaraEditorUtilities::GetFilteredScriptAssets filtered
  on Usage=DynamicInput + name substring if the canonical engine path
  doesn't resolve. Handles V2 asset-moves across UE versions.

Emitter stack graph introspection
- get_niagara_graph_nodes accepts emitter_name + script_usage so you can
  read EmitterUpdateScript / ParticleSpawnScript graphs directly — the
  actual graphs where stack modules appear as UNiagaraNodeFunctionCall
  nodes with visible override pins.

Renderer binding reader
- get_niagara_renderer_info now returns each binding with binding_name
  (the UPROPERTY name that set_niagara_renderer_binding accepts) +
  bound_variable + bound_variable_type + dataset_variable. Uses
  reflection to map binding pointers to their UPROPERTY names.

Describe-type fallback
- describe_niagara_type falls back to UEnum / UScriptStruct reflection
  when the name isn't in FNiagaraTypeRegistry, so script-property enums
  like ENiagaraScriptLibraryVisibility and custom project enums resolve
  cleanly.

FGraphNodeCreator contract fix
- Op / FunctionCall / ParameterMapGet / ParameterMapSet / Reroute / Input
  node creation now calls Creator.Finalize() before the creator goes out
  of scope. Previous templated helper returned early and tripped the
  bPlaced assert (EdGraph.h:312).

Bridge dispatcher prefix routing
- Added trace_niagara, validate_niagara, apply_niagara,
  apply_and_save_niagara, clear_niagara, find_niagara, resolve_niagara
  prefixes so the new command names reach the Niagara handler rather
  than falling through to the generic "Unknown command" error.

Python MCP wrappers
- New @mcp.tool() entries in unrealmcp/tools/niagara.py for all new
  commands with full docstrings, keyword arg support, and optional
  param handling. Nothing to regenerate — drop-in.

Go CLI parity
- cli/cmd/niagara.go now ships 96 Niagara CommandSpecs (was 54).
  Every C++ command has a matching Go entry with Short/Long docs,
  ue-cli ... --flag examples, typed params, and Required flags where
  the handler requires them. ue-cli.exe rebuilt.

Bonus: get_available_materials
- Added filter + max_results params so material listings can be
  scoped without returning engine-wide dumps.

Works on a real asset — verified end-to-end on NS_MuzzleFlash:
read Spawn Count's GetDataInterfaceLength binding recursively, clear
the nested Position Array link, re-link it through User.FlashPositions,
build a 1:1 replica DI from scratch with a real array-Length DI
function node, swap it onto SpawnPerFrame, set the nested int32001
local value to 250, and verified the full tree in a single binding
query. No hand-editing in the editor.

Author: aadeshrao123

Source/UnrealMCPBridge/Private/Commands/EpicUnrealMCPBlueprintCommands.cpp

@@ -789,6 +789,19 @@ TSharedPtr<FJsonObject> FEpicUnrealMCPBlueprintCommands::HandleGetAvailableMater
 		bIncludeEngineMaterials = Params->GetBoolField(TEXT("include_engine_materials"));
 	}
 
+	FString NameFilter;
+	Params->TryGetStringField(TEXT("filter"), NameFilter);
+
+	int32 MaxResults = 100;
+	if (Params->HasField(TEXT("max_results")))
+	{
+		double MaxResultsD = 100;
+		if (Params->TryGetNumberField(TEXT("max_results"), MaxResultsD))
+		{
+			MaxResults = static_cast<int32>(MaxResultsD);
+		}
+	}
+
 	FAssetRegistryModule& AssetRegistryModule =
 		FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
 	IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
@@ -866,6 +879,16 @@ TSharedPtr<FJsonObject> FEpicUnrealMCPBlueprintCommands::HandleGetAvailableMater
 	TArray<TSharedPtr<FJsonValue>> MaterialArray;
 	for (const FAssetData& AssetData : AssetDataArray)
 	{
+		if (MaxResults > 0 && MaterialArray.Num() >= MaxResults)
+		{
+			break;
+		}
+
+		if (!NameFilter.IsEmpty() && !AssetData.AssetName.ToString().Contains(NameFilter, ESearchCase::IgnoreCase))
+		{
+			continue;
+		}
+
 		TSharedPtr<FJsonObject> MaterialObj = MakeShared<FJsonObject>();
 		MaterialObj->SetStringField(TEXT("name"), AssetData.AssetName.ToString());
 		MaterialObj->SetStringField(TEXT("path"), AssetData.GetObjectPathString());

Source/UnrealMCPBridge/Private/Commands/EpicUnrealMCPNiagaraCommands.cpp

@@ -229,6 +229,88 @@ TSharedPtr<FJsonObject> FEpicUnrealMCPNiagaraCommands::HandleCommand(
 		return HandleRemoveNiagaraCustomHlslPin(Params);
 	}
 
+	// ---- Graph introspection (scratch pad / script graphs) ----
+	else if (CommandType == TEXT("get_niagara_graph_nodes"))
+	{
+		return HandleGetNiagaraGraphNodes(Params);
+	}
+	else if (CommandType == TEXT("get_niagara_node_info"))
+	{
+		return HandleGetNiagaraNodeInfo(Params);
+	}
+	else if (CommandType == TEXT("trace_niagara_connection"))
+	{
+		return HandleTraceNiagaraConnection(Params);
+	}
+	else if (CommandType == TEXT("validate_niagara_graph"))
+	{
+		return HandleValidateNiagaraGraph(Params);
+	}
+	else if (CommandType == TEXT("apply_niagara_scratch_pad"))
+	{
+		return HandleApplyNiagaraScratchPad(Params);
+	}
+	else if (CommandType == TEXT("apply_and_save_niagara_scratch_pad"))
+	{
+		return HandleApplyAndSaveNiagaraScratchPad(Params);
+	}
+	else if (CommandType == TEXT("get_niagara_script_properties"))
+	{
+		return HandleGetNiagaraScriptProperties(Params);
+	}
+	else if (CommandType == TEXT("set_niagara_script_properties"))
+	{
+		return HandleSetNiagaraScriptProperties(Params);
+	}
+	else if (CommandType == TEXT("list_niagara_script_parameters"))
+	{
+		return HandleListNiagaraScriptParameters(Params);
+	}
+	else if (CommandType == TEXT("add_niagara_script_parameter"))
+	{
+		return HandleAddNiagaraScriptParameter(Params);
+	}
+	else if (CommandType == TEXT("remove_niagara_script_parameter"))
+	{
+		return HandleRemoveNiagaraScriptParameter(Params);
+	}
+	else if (CommandType == TEXT("rename_niagara_script_parameter"))
+	{
+		return HandleRenameNiagaraScriptParameter(Params);
+	}
+	else if (CommandType == TEXT("add_niagara_graph_node"))
+	{
+		return HandleAddNiagaraGraphNode(Params);
+	}
+	else if (CommandType == TEXT("delete_niagara_graph_node"))
+	{
+		return HandleDeleteNiagaraGraphNode(Params);
+	}
+	else if (CommandType == TEXT("get_niagara_module_input_binding"))
+	{
+		return HandleGetNiagaraModuleInputBinding(Params);
+	}
+	else if (CommandType == TEXT("clear_niagara_module_input"))
+	{
+		return HandleClearNiagaraModuleInput(Params);
+	}
+	else if (CommandType == TEXT("list_niagara_input_source_menu"))
+	{
+		return HandleListNiagaraInputSourceMenu(Params);
+	}
+	else if (CommandType == TEXT("find_niagara_scratch_pad_usage"))
+	{
+		return HandleFindNiagaraScratchPadUsage(Params);
+	}
+	else if (CommandType == TEXT("resolve_niagara_built_in_dynamic_input"))
+	{
+		return HandleResolveNiagaraBuiltInDynamicInput(Params);
+	}
+	else if (CommandType == TEXT("list_niagara_data_interface_functions"))
+	{
+		return HandleListNiagaraDataInterfaceFunctions(Params);
+	}
+
 	// ---- Node discovery & schema introspection ----
 	else if (CommandType == TEXT("list_niagara_node_types"))
 	{

Source/UnrealMCPBridge/Private/Commands/Niagara/NiagaraDiscovery.cpp

@@ -10,6 +10,7 @@
 #include "NiagaraGraph.h"
 #include "NiagaraDataInterface.h"
 #include "NiagaraTypes.h"
+#include "NiagaraTypeRegistry.h"
 #include "NiagaraCommon.h"
 
 #include "AssetRegistry/AssetRegistryModule.h"
@@ -311,84 +312,182 @@ TSharedPtr<FJsonObject> FEpicUnrealMCPNiagaraCommands::HandleListNiagaraDataInte
 // HandleListNiagaraParameterTypes
 // ---------------------------------------------------------------------------
 
+// Live query against FNiagaraTypeRegistry. Mirrors the "+" menu in the Niagara
+// editor's User Parameters panel — any type Niagara knows about (built-in,
+// Niagara-registered struct, enum, or plugin-registered Data Interface) is
+// returned. Filters: name substring, scope (user/system/emitter/particle/all),
+// kind (primitive/struct/enum/data_interface), max_results.
 TSharedPtr<FJsonObject> FEpicUnrealMCPNiagaraCommands::HandleListNiagaraParameterTypes(
 	const TSharedPtr<FJsonObject>& Params)
 {
-	FString Scope = TEXT("all");
+	FString Scope = TEXT("user");
 	Params->TryGetStringField(TEXT("scope"), Scope);
 
-	// Common Niagara parameter types available for user parameters
-	struct FTypeEntry
+	FString Kind = TEXT("all");
+	Params->TryGetStringField(TEXT("kind"), Kind);
+
+	FString NameFilter;
+	Params->TryGetStringField(TEXT("filter"), NameFilter);
+
+	int32 MaxResults = 500;
 	{
-		const TCHAR* Name;
-		const TCHAR* Description;
-		const TCHAR* Scope;
-	};
+		double MaxResultsD = 500.0;
+		if (Params->TryGetNumberField(TEXT("max_results"), MaxResultsD))
+		{
+			MaxResults = static_cast<int32>(MaxResultsD);
+		}
+	}
 
-	static const FTypeEntry Types[] =
-	{
-		// Primitive types (available in all scopes)
-		{ TEXT("float"), TEXT("32-bit floating point"), TEXT("all") },
-		{ TEXT("int32"), TEXT("32-bit signed integer"), TEXT("all") },
-		{ TEXT("bool"), TEXT("Boolean value"), TEXT("all") },
-
-		// Vector types
-		{ TEXT("Vector2D"), TEXT("2D vector (X, Y)"), TEXT("all") },
-		{ TEXT("Vector"), TEXT("3D vector (X, Y, Z)"), TEXT("all") },
-		{ TEXT("Vector4"), TEXT("4D vector (X, Y, Z, W)"), TEXT("all") },
-
-		// Color
-		{ TEXT("LinearColor"), TEXT("Linear color (R, G, B, A)"), TEXT("all") },
-
-		// Transform
-		{ TEXT("Quat"), TEXT("Quaternion rotation"), TEXT("all") },
-		{ TEXT("Matrix"), TEXT("4x4 matrix"), TEXT("particle") },
-		{ TEXT("Position"), TEXT("World-space position (LWC)"), TEXT("all") },
-
-		// Niagara-specific
-		{ TEXT("NiagaraID"), TEXT("Niagara particle ID"), TEXT("particle") },
-		{ TEXT("NiagaraSpawnInfo"), TEXT("Spawn info struct"), TEXT("emitter") },
-		{ TEXT("NiagaraParameterMap"), TEXT("Parameter map"), TEXT("system") },
-
-		// Enums
-		{ TEXT("ENiagaraExecutionState"), TEXT("Emitter execution state enum"), TEXT("emitter") },
-		{ TEXT("ENiagaraCoordinateSpace"), TEXT("Coordinate space enum"), TEXT("all") },
-		{ TEXT("ENiagaraOrientationAxis"), TEXT("Orientation axis enum"), TEXT("all") },
-
-		// Data interfaces (user parameter scope)
-		{ TEXT("Texture2D"), TEXT("2D texture reference"), TEXT("user") },
-		{ TEXT("TextureCube"), TEXT("Cube texture reference"), TEXT("user") },
-		{ TEXT("StaticMesh"), TEXT("Static mesh reference"), TEXT("user") },
-		{ TEXT("SkeletalMesh"), TEXT("Skeletal mesh reference"), TEXT("user") },
+	// Resolve scope → registry query. "all" returns every registered type.
+	TArray<FNiagaraTypeDefinition> Types;
+	const FString LowerScope = Scope.ToLower();
+	if (LowerScope == TEXT("user"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredUserVariableTypes();
+	}
+	else if (LowerScope == TEXT("system"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredSystemVariableTypes();
+	}
+	else if (LowerScope == TEXT("emitter"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredEmitterVariableTypes();
+	}
+	else if (LowerScope == TEXT("particle"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredParticleVariableTypes();
+	}
+	else if (LowerScope == TEXT("parameter"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredParameterTypes();
+	}
+	else if (LowerScope == TEXT("payload"))
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredPayloadTypes();
+	}
+	else if (LowerScope == TEXT("numeric"))
+	{
+		Types = FNiagaraTypeRegistry::GetNumericTypes();
+	}
+	else if (LowerScope == TEXT("index"))
+	{
+		Types = FNiagaraTypeRegistry::GetIndexTypes();
+	}
+	else
+	{
+		Types = FNiagaraTypeRegistry::GetRegisteredTypes();
+	}
+
+	const FString LowerKind = Kind.ToLower();
+
+	auto ClassifyKind = [](const FNiagaraTypeDefinition& T) -> FString
+	{
+		if (T.IsDataInterface()) return TEXT("data_interface");
+		if (T.IsEnum())           return TEXT("enum");
+		if (T.IsUObject())        return TEXT("object");
+		if (T.GetScriptStruct())  return TEXT("struct");
+		return TEXT("primitive");
 	};
 
 	TArray<TSharedPtr<FJsonValue>> TypesArr;
-	FString LowerScope = Scope.ToLower();
-
-	for (const FTypeEntry& Entry : Types)
+	int32 TotalMatched = 0;
+	for (const FNiagaraTypeDefinition& TypeDef : Types)
 	{
-		if (LowerScope != TEXT("all"))
+		if (!TypeDef.IsValid())
+		{
+			continue;
+		}
+
+		const FString EntryKind = ClassifyKind(TypeDef);
+		if (LowerKind != TEXT("all") && !EntryKind.Equals(LowerKind, ESearchCase::IgnoreCase))
+		{
+			continue;
+		}
+
+		const FString EntryName = TypeDef.GetName();
+		if (!NameFilter.IsEmpty() && !EntryName.Contains(NameFilter, ESearchCase::IgnoreCase))
 		{
-			FString EntryScope = Entry.Scope;
-			if (!EntryScope.Equals(TEXT("all"), ESearchCase::IgnoreCase) &&
-				!EntryScope.Equals(Scope, ESearchCase::IgnoreCase))
+			// For data interfaces, also allow matching without the "NiagaraDataInterface" prefix
+			if (!(TypeDef.IsDataInterface() && EntryName.Replace(TEXT("NiagaraDataInterface"), TEXT("")).Contains(NameFilter, ESearchCase::IgnoreCase)))
 			{
 				continue;
 			}
 		}
 
+		TotalMatched++;
+		if (TypesArr.Num() >= MaxResults)
+		{
+			continue;
+		}
+
 		auto Obj = MakeShared<FJsonObject>();
-		Obj->SetStringField(TEXT("name"), Entry.Name);
-		Obj->SetStringField(TEXT("description"), Entry.Description);
-		Obj->SetStringField(TEXT("scope"), Entry.Scope);
+		Obj->SetStringField(TEXT("name"), EntryName);
+		Obj->SetStringField(TEXT("kind"), EntryKind);
+		Obj->SetNumberField(TEXT("size_bytes"), TypeDef.GetSize());
+
+		if (TypeDef.IsDataInterface())
+		{
+			if (UClass* Cls = TypeDef.GetClass())
+			{
+				Obj->SetStringField(TEXT("class_path"), Cls->GetPathName());
+				// Convenience short name — strips engine-internal prefix so users
+				// can reference "ArrayFloat" instead of "NiagaraDataInterfaceArrayFloat"
+				FString Short = Cls->GetName();
+				if (Short.StartsWith(TEXT("NiagaraDataInterface")))
+				{
+					Short.RightChopInline(FString(TEXT("NiagaraDataInterface")).Len());
+					Obj->SetStringField(TEXT("short_name"), Short);
+				}
+				// Category from metadata (used by editor "+"-menu grouping)
+#if WITH_EDITOR
+				const FString Category = Cls->GetMetaData(TEXT("Category"));
+				if (!Category.IsEmpty())
+				{
+					Obj->SetStringField(TEXT("category"), Category);
+				}
+				const FString Tooltip = Cls->GetMetaData(TEXT("ToolTip"));
+				if (!Tooltip.IsEmpty())
+				{
+					Obj->SetStringField(TEXT("description"), Tooltip);
+				}
+#endif
+			}
+		}
+		else if (TypeDef.IsEnum())
+		{
+			if (UEnum* Enum = TypeDef.GetEnum())
+			{
+				Obj->SetStringField(TEXT("enum_path"), Enum->GetPathName());
+				Obj->SetNumberField(TEXT("num_entries"), Enum->NumEnums());
+			}
+		}
+		else if (UScriptStruct* Struct = TypeDef.GetScriptStruct())
+		{
+			Obj->SetStringField(TEXT("struct_path"), Struct->GetPathName());
+#if WITH_EDITOR
+			const FString Tooltip = Struct->GetMetaData(TEXT("ToolTip"));
+			if (!Tooltip.IsEmpty())
+			{
+				Obj->SetStringField(TEXT("description"), Tooltip);
+			}
+#endif
+		}
+
 		TypesArr.Add(MakeShared<FJsonValueObject>(Obj));
 	}
 
 	auto Result = MakeShared<FJsonObject>();
 	Result->SetBoolField(TEXT("success"), true);
-	Result->SetStringField(TEXT("scope_filter"), Scope);
+	Result->SetStringField(TEXT("scope"), Scope);
+	Result->SetStringField(TEXT("kind_filter"), Kind);
+	if (!NameFilter.IsEmpty())
+	{
+		Result->SetStringField(TEXT("name_filter"), NameFilter);
+	}
 	Result->SetArrayField(TEXT("types"), TypesArr);
 	Result->SetNumberField(TEXT("count"), TypesArr.Num());
+	Result->SetNumberField(TEXT("total_matched"), TotalMatched);
+	Result->SetNumberField(TEXT("max_results"), MaxResults);
 	return Result;
 }