Blueprint

104 tools. Back to the index.

add_actor_begin_overlap_event

Additive, idempotent.

Add a real AActor event OVERRIDE node (bOverrideFunction set, so it is not an eclipsed stub) -- ReceiveActorBeginOverlap by default, or any other AActor event via event_name (ReceiveActorEndOverlap, ReceiveHit, ReceiveBeginPlay...) -- and compile. Idempotent: an existing override of that event in the graph is returned with already_exists:true. It only reaches events declared on the ACTOR; for a component's delegate use add_component_bound_event, and for an interface member use override_interface_member.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor Blueprint.
event_name	string	no	AActor event function to override; defaults to "ReceiveActorBeginOverlap". Must exist on the Blueprint's class or the call errors.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...the event's output params...], blueprint_name, graph_name, event_name, is_override, already_exists? } -- is_override:true is what distinguishes a live override from a dead look-alike; already_exists is only present when an existing node was reused.

add_ai_perception_sense

Additive, idempotent.

Configure a sight or hearing sense on an AIPerceptionComponent TEMPLATE of a Blueprint, creating the config as an Instanced subobject of the template so it persists with the asset, and saving the package. Idempotent: ConfigureSense dedups by config class, so re-calling with the same sense_type UPDATES the existing config in place instead of stacking a second one. Only "sight" and "hearing" are supported (no damage, touch or team senses). It authors the TEMPLATE only -- whether the AI actually perceives anything is a live-PIE question this cannot answer; read the authored result back with get_ai_perception_senses.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint owning the component
component_name	string	yes	Name of the AIPerceptionComponent SCS node
sense_type	string	yes	"sight" or "hearing"
dominant	boolean	no	Optional bool; if true, sets this sense as the component's dominant sense
sight_radius	number	no	(sight) Maximum sight distance, cm (ClampMin 0)
lose_sight_radius	number	no	(sight) Distance to keep seeing an already-seen target, cm (ClampMin 0)
peripheral_vision_angle	number	no	(sight) Peripheral vision half-angle, degrees (Clamp 0..180)
hearing_range	number	no	(hearing) Hearing range, cm (ClampMin 0)
detect_enemies	boolean	no	Optional bool affiliation filter
detect_neutrals	boolean	no	Optional bool affiliation filter
detect_friendlies	boolean	no	Optional bool affiliation filter

Returns: { blueprint_name, component_name, sense_type, config_class, <sense fields>, note }

add_blueprint_function

Destructive.

Create a NEW function graph on a Blueprint, or with override=true a real OVERRIDE of an inherited/interface member (delegated to implement_interface_function, so an event-shape member becomes an event override node and a value-returning one an override graph). It REFUSES rather than guessing: a name that collides with an overridable inherited function errors with a hint instead of silently creating a "<name>_0" shadow, and an EVENT-shape member already shadowed by a local function graph errors telling you to remove that graph first. The new graph does not exist in the generated class until compile_blueprint, so compile BEFORE add_function_parameter or any node that calls it -- otherwise a build_blueprint_graph step fails with "Function not found" and rolls the whole batch back.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
function_name	string	yes	Name for the new function; with override=true, the EXACT name of the inherited (interface or parent-class) function to override.
override	boolean	no	Optional. When true, create an OVERRIDE of an inherited function ('My Blueprint > Override'): resolves the interface/parent-virtual signature and creates the override graph (function-shape) or event override node (event-shape) with the inherited signature + exact name -- NOT a new deduped function. When omitted and the name collides with an inherited overridable function, the call errors with a hint (instead of silently making a '<name>_0' shadow); pass override=false to force a brand-new function anyway.

Returns: { blueprint_name: string, function_name: string, graph_name: string, success: bool [, kind, already_existed, node_id, already_exists, is_interface_function, note] } -- with override=true the payload is implement_interface_function's (kind='function'|'event', graph_name or node_id). success:true can come back WITHOUT the graph actually appearing, so confirm with get_blueprint_functions before wiring it.

add_blueprint_variable

Additive.

Add a MEMBER variable to a Blueprint (add_function_local_variable is the function-scoped twin), then read/write it with add_graph_node node_type=variable_get/variable_set. TRAP 1: the variable is born NOT editable per instance -- placing the actor and writing that variable fails with "cannot be edited on instances" -- and get_blueprint_variables reports instance_editable:true anyway; fix it with set_bp_variable_metadata(instance_editable=true). TRAP 2: on a class that ALREADY has actors placed in a level, those instances keep the value of the first compile, so a default set afterwards never reaches them -- verify on the instances, not on the CDO.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
variable_name	string	yes	New variable name (fails if the name already exists on this Blueprint).
variable_type	string	yes	Type string: bool, int, int64, float, string, name, text, byte, or the name/path of a struct, enum, class or object (e.g. Vector, /Game/Dir/S_Foo.S_Foo, /Script/Engine.Actor).
is_array	boolean	no	When true, make the variable an array container; defaults to false. This is the ONLY array authoring path -- add_function_parameter has no equivalent.
default_value	string	no	Initial default value for the new variable, in exported-text form; optional

Returns: { blueprint_name, variable_name, variable_type, is_array } -- an echo of the request, NOT a verification: read the variable back with get_blueprint_variables (or the CDO) before relying on it.

add_branch_node

Additive.

Add a Branch (if/then/else) node -- pins 'execute', 'Condition', 'then' (true), 'else' (false) -- AND compile the Blueprint as a side effect. add_graph_node node_type="branch" creates the identical node without compiling, which is what you want inside a build_blueprint_graph batch; use this one when a standalone compile is wanted anyway. Leaving 'else' unwired is legitimate and lint_blueprint_graph will not flag it, except inside a function that returns a value (function_exit_without_return).

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[execute, Condition, then, else], blueprint_name, graph_name }

add_break_struct_node

Additive.

Create a Break Struct node with ONE OUTPUT PIN PER MEMBER of the struct (Blueprint-defined structs included) and return them all, so each field can be read out with connect_pins without a follow-up read. Same node as add_graph_node node_type="break_struct", but reconstructed after creation so the per-member pins are refreshed from the struct. Inverse: add_make_struct_node. Does NOT compile.

Parameter	Type	Required	Description
blueprint_name	string	no	Blueprint name or path.
struct_type	string	no	UScriptStruct path (/Game/.../S_Foo.S_Foo), bare name, or engine alias (Vector/Rotator/Transform...).
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
position_x	string	no	Node X position (ignored when node_position is set).
position_y	string	no	Node Y position (ignored when node_position is set).
node_position	string	no	Node canvas position as [x, y]; takes precedence over position_x/position_y.

Returns: { node_id, pins:[...the struct input + one output pin per struct member...], blueprint_name, graph_name, struct_type }

add_broadcast_node

Additive.

Add the node that BROADCASTS (fires) an event dispatcher on self -- own or inherited -- with one input pin per signature parameter, so listeners run. Does NOT compile. The dispatcher must already exist in the compiled class (add_event_dispatcher then compile_blueprint), and its parameter pins only appear after set_event_dispatcher_signature. The opposite direction (LISTENING) is add_graph_node node_type="add_delegate" for self, add_object_bound_event for another object's dispatcher.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint that owns (or inherits) the dispatcher
dispatcher_name	string	yes	Exact name of the multicast delegate to broadcast; resolved on the skeleton class, so inherited dispatchers work
graph_name	string	no	Target graph; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[execute, then, one input per signature param], blueprint_name, graph_name, dispatcher_name } -- an empty parameter list means the dispatcher has no signature yet.

add_call_library_function

Additive.

Add a call node for a STATIC library function -- an engine library by name (KismetMathLibrary, KismetSystemLibrary, GameplayStatics, KismetStringLibrary, or any other /Script/Engine class) or a USER BlueprintFunctionLibrary by asset path -- and compile. Prefer add_graph_node node_type="call_function" when the target is a member function of an actor/component. Plan the wiring with get_function_pins, which returns the exact pin names WITHOUT creating anything. TRAP inside build_blueprint_graph: the parameter is 'function_library'; passing 'class_name' fails only THAT step ("Missing required parameter: function_library") while the batch continues, leaving every connection that needed the node reporting "Target node not found".

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
function_library	string	yes	A standard engine function library ("KismetMathLibrary", "KismetSystemLibrary", "GameplayStatics", "KismetStringLibrary", with or without the U prefix) OR a user BlueprintFunctionLibrary asset path ("/Game/Dir/BFL_X", "/Game/Dir/BFL_X.BFL_X", or the "..._C" generated class).
function_name	string	yes	Exact UFunction name on that library (e.g. "Abs", "MakeVector", "PrintString"); get_function_pins resolves and previews it first.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...every param pin, already named...], blueprint_name, graph_name, function_library, function } -- pins come back with the node, so connect_pins/set_pin_default_value need no follow-up read.

add_cast_node

Additive.

Add an IMPURE Cast To <Class> node (exec in, Cast Succeeded / Cast Failed out) and compile the Blueprint. Same node as add_graph_node node_type="cast", which does NOT compile -- use that one inside a build_blueprint_graph batch. Skip the cast entirely when it only exists to type a GetComponentByClass result: add_get_component_by_class_node returns a ReturnValue pin already typed to the component class.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
target_class_name	string	yes	Class to cast to: a name ("Pawn", "Character"), a /Script/Module.Class path, or a Blueprint generated-class path (/Game/Dir/BP_X.BP_X_C).
target_class	string	no	Alias accepted instead of target_class_name (same meaning); one of the two is required.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...], blueprint_name, graph_name, cast_to } -- the node WITH its pins ('execute', 'Object', 'then'/Cast Succeeded, 'CastFailed', 'As<Class>'), so it can be wired without a follow-up read.

add_comment_node

Destructive.

Add a resizable comment box (UEdGraphNode_Comment) to a graph. KNOWN BUG: the 'text' parameter is LOST -- the comment is assigned before the node is finalized and the engine's PostPlacedNewNode then overwrites it, so every box created this way reads "Comment"; the returned "comment" field is the oracle and there is no MCP way to fix it (write the rationale in the system's docs instead, and delete the empty box). It also has NO pins, so a pin_defaults entry aimed at it breaks a whole build_blueprint_graph batch.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
text	string	no	Comment text; currently IGNORED (see the bug above), the box always ends up saying "Comment"
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
width	number	no	Comment box width in pixels; defaults to 400
height	number	no	Comment box height in pixels; defaults to 200
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pos_x, pos_y, comment } -- no pins array. comment=="Comment" means the requested text was not written.

add_component_bound_event

Additive, idempotent.

Bind a multicast delegate OF ONE OF THIS BLUEPRINT'S OWN COMPONENTS (OnComponentBeginOverlap, OnComponentHit, a vendor component's dispatcher...) to a generated handler event in the event graph -- the editor's component-event flow -- then compile and re-check that the binding registered (bound). ALSO WORKS ON A WIDGET BLUEPRINT: pass the WBP and a WIDGET's name as component_name to wire a Button's OnClicked, a Slider's OnValueChanged, a CheckBox's OnCheckStateChanged -- exactly what the Designer's "+ OnClicked" green button does, and the only headless route to it (bound:true, with a BndEvt__..._OnButtonClickedEvent created). A UMG widget is not an SCS component but IS a property of the generated class, which is all this needs. Idempotent: an identical binding is returned instead of duplicated. The Blueprint must already be compiled, since the component/widget has to exist as a property of the generated class. For a dispatcher on an object that is NOT self and NOT one of its components, use add_object_bound_event; for one on SELF, add_graph_node node_type="add_delegate".

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor Blueprint OR a Widget Blueprint (already compiled).
component_name	string	yes	SCS component variable name on this Blueprint (e.g. "BodyMesh"), OR -- on a Widget Blueprint -- the name of a widget in its tree (e.g. "Btn_Play"); resolved on the skeleton class, so inherited components and widgets work too.
delegate_name	string	yes	Exact multicast delegate property name on the COMPONENT's class (e.g. "OnComponentBeginOverlap"). On a miss the error names the component class so the right delegate can be looked up.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...the delegate's params as OUTPUT pins...], blueprint_name, graph_name, component_name, delegate, custom_function_name, bound, already_exists? } -- bound is a post-compile re-lookup (the real oracle); already_exists is only present when an existing binding was reused.

add_component_to_blueprint

Additive.

Add a component to a Blueprint's SCS (engine class or a Blueprint AC_* class) with an optional relative transform and parent, then compile. TRAP 1: on a CHILD Blueprint whose scene root is INHERITED, a SCENE component can end up written into the PARENT's SCS (source:"inherited", owner_class = the parent) -- which silently edits a vendor/library asset; non-scene ActorComponents land correctly on the child. TRAP 2: a scene component of a BLUEPRINT class, or one given a location, can report success without persisting and then materialize LATER as a duplicate. Both have the same oracle: get_blueprint_scs_tree right after, checking owner_class and source of the new node -- never the return value.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_type	string	yes	Component class: a native short name ('StaticMesh', 'Box', 'Sphere'), a /Script path ('/Script/Engine.StaticMeshComponent'), OR a Blueprint component class given as its object path ('/Game/.../AC_Foo.AC_Foo_C'), a bare package path ('/Game/.../AC_Foo'), or a bare '<Name>_C' ('AC_Foo_C').
component_name	string	yes	Name for the new component instance
location	array	no	Optional [x, y, z] relative location for scene components
rotation	array	no	Optional [pitch, yaw, roll] relative rotation for scene components
scale	array	no	Optional [x, y, z] relative scale for scene components
transform	object	no	Optional {"location":[x,y,z], "rotation":[p,y,r], "scale":[x,y,z]} alias for scene components; any flat location/rotation/scale arg above wins over the matching axis in here if both are given.
parent_component_name	string	no	Optional parent for scene components; omit / "root" attaches under the Blueprint's EXISTING scene root (SCS or native) instead of force-adding a second orphan root node. May also name a NATIVE inherited scene component (e.g. ACharacter's "CharacterMesh0"), mirroring attach_blueprint_component. Ignored for non-scene ActorComponents (no transform, no hierarchy to join).
socket_name	string	no	Optional socket/bone name on the parent (AttachToName)

Returns: { component_name: string, component_type: string } -- an ECHO of the request with no owner, no source and no verification. It says nothing about WHERE the node landed: read get_blueprint_scs_tree afterwards.

add_custom_event_node

Additive, idempotent.

Add a NEW Custom Event node (an entry point you invent, not an override of anything) and compile. Idempotent by name: an existing custom event with that name in the graph is returned with already_existed:true, because re-adding one compiles into "more than one function with the same name" and breaks the Blueprint. HARD LIMIT: a custom event cannot be given PARAMETERS -- add_function_parameter answers "Function graph not found" and there is no other route -- so anything that needs arguments (an RPC in particular) must be a function instead. To override an inherited/interface event use override_interface_member.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
event_name	string	yes	Name for the custom event (becomes CustomFunctionName). Must not collide with an overridable inherited function or lint_blueprint_graph flags it as custom_event_shadowing_override.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...], blueprint_name, graph_name, event_name, node_title, already_existed } -- the node WITH its pins ('then' and the delegate output), ready for connect_pins. already_existed is only present when an existing event was reused.

add_enhanced_input_action_node

Additive.

Add an Enhanced Input action event node (UK2Node_EnhancedInputAction) bound to a UInputAction asset. Unlike add_input_action_event_node -- which creates the LEGACY UK2Node_InputAction that does NOT fire under Enhanced Input -- this node exposes the real ETriggerEvent exec pins (Triggered/Started/Ongoing/Canceled/Completed) that fire from the Enhanced Input pipeline. Use this instead of polling IsInputKeyDown in a timer; it is rebind-aware (bound to the InputAction asset, not a raw key).

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor/Pawn Blueprint.
input_action	string	yes	Asset path (or short name) of the UInputAction to bind, e.g. "/Game/Input/IA_Crouch".
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, pins:[{name, direction, type, linked_to, default}], blueprint_name, graph_name, input_action, node_class } -- the created node WITH its freshly-allocated pins: ETriggerEvent exec outputs (Triggered/Started/Ongoing/Canceled/Completed) plus data outputs (ActionValue/ElapsedSeconds/TriggeredSeconds/InputAction). Wire it via connect_pins WITHOUT a follow-up get_graph_nodes.

add_event_dispatcher

Additive.

Create an event dispatcher (multicast delegate) on a Blueprint: adds BOTH the delegate member variable and its signature graph, the way the editor's "+ Event Dispatcher" does. It starts with NO parameters -- give it a signature with set_event_dispatcher_signature. Everything downstream needs the class REGENERATED first, so compile_blueprint before add_broadcast_node (to fire it) or add_graph_node node_type="add_delegate" / add_object_bound_event (to listen).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
dispatcher_name	string	yes	Name of the new event dispatcher; fails if a member variable of that name already exists

Returns: { blueprint_name, dispatcher_name, created } -- created is always true on success; confirm with get_event_dispatchers.

add_function_local_variable

Additive.

Add a variable scoped to ONE function graph (interface-override graphs included), instead of a class member like add_blueprint_variable -- use it for scratch state that no other graph should see. Reach it from the graph with add_graph_node node_type=variable_get/variable_set and scope="local" (the default scope="auto" already prefers a local over a member of the same name).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
function_name	string	yes	Name of an existing function graph (FunctionGraphs or an interface-override graph)
variable_name	string	yes	Variable name; the call fails if the name already exists in that function
variable_type	string	yes	Type string: bool, int, int64, float, string, name, text, byte, Vector, or a struct/enum/class/object name or path
default_value	string	no	Initial default value for the local variable, in exported-text form; optional

Returns: { blueprint_name, function_name, variable_name, variable_type } -- an echo of the request; local variables do NOT appear in get_blueprint_variables (which lists members), so verify from the graph itself.

add_function_parameter

Additive.

Add an input or output (return) parameter to an existing Blueprint FUNCTION graph -- interface-override graphs included -- and reconstruct its Entry/Result node. TWO HARD LIMITS, both silent-ish: it cannot create an ARRAY parameter (there is no is_array; the param comes out SCALAR with success), so redesign the signature to read the array where it lives; and it cannot reach a CUSTOM EVENT ("Function graph not found"), so a Server/Client RPC WITH arguments must be authored as a function plus set_bp_function_rpc. On a Blueprint just given a new function, compile_blueprint between creation and this call.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
function_name	string	yes	Name of an existing function graph (FunctionGraphs or an interface-override graph). A custom event is NOT a function graph and is rejected here.
param_name	string	yes	New parameter name; made unique, so the applied name is the one echoed back in the response.
param_type	string	yes	Type string: bool, int, int64, float, string, name, text, byte, Vector, or a struct/enum/class/object name or path. Arrays are NOT expressible.
is_output	boolean	no	When true, add an output/return param (an input pin on the Result node) instead of an input; defaults to false

Returns: { blueprint_name, function_name, param_name, param_type, is_output } -- param_name is the pin name actually created (uniquified). Verify with get_graph_nodes at compact=false: compact hides the new, still-unlinked pin and makes it look like nothing was created.

add_get_component_by_class_node

Additive.

Add a GetComponentByClass node BORN TYPED: the ComponentClass pin is set before the node is reconstructed, so ReturnValue comes out as that component class instead of the generic ActorComponent and no cast is needed. Use it instead of add_graph_node + a pin_defaults entry: inside build_blueprint_graph the defaults are applied AFTER the connections, so a still-generic node fails to connect ("Actor Component Object Reference is not compatible with ...") and, with stop_on_error's default true, takes the whole batch down with it.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint to add the node to
component_class	string	yes	Component class to fetch: short name, /Script/Module.Class, or a /Game Blueprint component path. Must be a UActorComponent subclass or the call errors.
graph_name	string	no	Target graph; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...], blueprint_name, graph_name, component_class, return_pin_type } -- return_pin_type is the ORACLE: if it does not name the requested component class, the pin stayed generic and connecting it will fail.

add_graph_node

Additive.

Create ONE node in a Blueprint's event/function graph (node_type selects the kind) and return it WITH its freshly allocated pins, so connect_pins / set_pin_default_value can wire it immediately without a follow-up get_graph_nodes. Use build_blueprint_graph instead when several nodes must be created AND wired in a single undo transaction, and get_function_pins to learn a call_function's pin names BEFORE creating anything. node_type='event' creates a REAL override (the declaring interface/parent class is resolved automatically and bOverrideFunction is set; target_class is ignored here) and fails loudly for a name that is not an overridable event -- an interface method WITH a return value is not an event, use implement_interface_function.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name (resolved under /Game/Blueprints) or full asset path. Pass the FULL path when the short name is ambiguous: a bare name that matches two assets resolves to one of them silently.
node_type	string	yes	One of event, custom_event, call_function, print_string, variable_get, variable_set, branch, sequence, self, cast, spawn_actor (alias spawn_actor_from_class), create_widget, make_struct, break_struct, get_array_item, select, make_array, make_set, make_map, switch_int, switch_string, switch_name, switch_enum, enum_literal, format_text, foreach, foreach_with_break, do_once, gate, flipflop, for_loop, while_loop, is_valid, add_delegate, macro_instance
event_name	string	yes	Event name; required for event and custom_event node types
function_name	string	yes	Function to call; required for call_function node type
target_class	string	yes	Class owning the function or cast/spawn target class. For variable_get/variable_set it names the class that owns the variable, producing a non-self member-access node (with a 'target' pin) instead of a self-context node. For create_widget it names the widget class to construct (e.g. WBP_Foo_C, a full asset path, or the widget Blueprint short name); the node exposes that widget's Expose-On-Spawn pins.
variable_name	string	yes	Variable to get/set; required for variable_get and variable_set
struct_type	string	yes	Struct type; required for make_struct and break_struct nodes
enum_path	string	yes	Enum path or name; required for switch_enum and enum_literal nodes
dispatcher	string	yes	Event-dispatcher (multicast delegate) name; required for add_delegate node type. Must already exist in the COMPILED class (add_event_dispatcher + compile_blueprint), and it binds on self only -- for a dispatcher on another class use add_object_bound_event.
macro_graph_name	string	yes	Macro graph name; required for node_type=macro_instance. Resolved against this Blueprint's own MacroGraphs first, then the engine StandardMacros.
scope	string	no	Optional scope hint for variable_get/variable_set: 'auto' (default; a function-local variable declared in the target graph wins, else a self/member variable), 'local' (function-local variable ONLY), or 'member' (member variable only -- self, or on target_class when supplied). Ignored by other node types.
num_inputs	number	no	Optional input-pin count for make_array/make_set/make_map (added after spawn)
cases	string	no	Optional string array of case pins for switch_int/switch_string/switch_name
arguments	string	no	Optional string array of argument names for format_text
macro_source	string	no	Set to "standard_macros" to skip this Blueprint's own MacroGraphs and resolve macro_graph_name only in the engine StandardMacros library. Only read for node_type=macro_instance.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pos_x, pos_y, comment, pins:[{name, direction:'input'|'output', type, linked_to, default}], blueprint_name, graph_name } -- the created node WITH its freshly-allocated pins. The pin names are already here, so you can wire the node via connect_pins/set_pin_default_value WITHOUT a follow-up get_graph_nodes. Read "class" as a sanity check: a node_type that was expected to produce an async/latent node and comes back as "K2Node_CallFunction" is a mute no-op that still compiles 0/0.

add_input_action_event_node

Additive.

Add the LEGACY action-mapping event node (UK2Node_InputAction) bound to an action mapping NAME, and compile. WARNING: this node does NOT fire under Enhanced Input, which is what UE5 projects use -- it compiles clean and simply never runs. For an Enhanced Input action asset use add_enhanced_input_action_node, whose Triggered/Started/Completed pins actually execute. Only reach for this one on a project still using the legacy input mappings.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor/Pawn Blueprint (SupportsInputEvents is enforced).
input_action_name	string	yes	Name of the LEGACY action mapping. It is not validated against the project's mappings: a typo yields a node that never fires.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[Pressed, Released, Key], blueprint_name, graph_name, input_action_name, node_class } -- node_class should read K2Node_InputAction (the legacy node); nothing here proves the mapping exists.

add_macro_instance_node

Additive.

Instantiate a macro from a macro LIBRARY asset ("/Game/Lib/ML_X.ML_X:MyMacro", or the library path plus macro_graph) -- the only way to reach a third-party or project macro library, since add_graph_node's macro aliases (foreach, do_once, gate, is_valid...) only look inside the engine StandardMacros. With no library path it falls back to this Blueprint's own MacroGraphs and then StandardMacros. Does NOT compile. Its pins start WILDCARD and only re-type once something is connected, which connect_pins handles by reconstructing the node.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint to add the node to.
macro	string	yes	Macro identifier: "<macro-library-path>:<MacroGraphName>" (e.g. "/Game/Lib/ML_X.ML_X:MyMacro"), OR just the library asset path with the graph name in 'macro_graph', OR a bare graph name to resolve against this Blueprint's own MacroGraphs and then the engine StandardMacros.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
macro_graph	string	no	Macro graph name, used when 'macro' is a library path with no ":<GraphName>" suffix.
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, input_pins:[string], output_pins:[string], blueprint_name, graph_name } -- pin NAMES only, split by direction (no types or defaults); use get_node_pin_info on the node_id when the types matter.

add_make_struct_node

Additive.

Create a Make Struct node with ONE INPUT PIN PER EDITABLE MEMBER of the struct (Blueprint-defined structs included) and return them all, so the struct can be filled with set_pin_default_value / connect_pins without a follow-up read. Same node as add_graph_node node_type="make_struct", but reconstructed after creation so the per-member pins are refreshed from the struct. Inverse: add_break_struct_node. Does NOT compile.

Parameter	Type	Required	Description
blueprint_name	string	no	Blueprint name or path.
struct_type	string	no	UScriptStruct path (/Game/.../S_Foo.S_Foo), bare name, or engine alias (Vector/Rotator/Transform...).
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
position_x	string	no	Node X position (ignored when node_position is set).
position_y	string	no	Node Y position (ignored when node_position is set).
node_position	string	no	Node canvas position as [x, y]; takes precedence over position_x/position_y.

Returns: { node_id, pins:[...one input pin per struct member + the struct output...], blueprint_name, graph_name, struct_type }

add_object_bound_event

Additive.

Bind a BlueprintAssignable event dispatcher of an EXTERNAL object (not self, not a component) to a handler custom event -- the editor's right-click "Assign" flow (FEdGraphSchemaAction_K2AssignDelegate). Use this to react to a dispatcher on a widget/actor instance held in a variable (e.g. a UMG widget's "On Radial Menu Item Selected"): it spawns a UK2Node_AddDelegate bound to target_class' dispatcher with its self/target pin LEFT UNCONNECTED (you wire the instance) and a UK2Node_CustomEvent whose OUTPUT pins mirror the dispatcher's params (e.g. the segment-data struct), already wired to the AddDelegate's Delegate pin. Unlike the add_delegate node_type (self-context only), this reaches a dispatcher on a foreign class. Does NOT compile the Blueprint (mirrors the engine action); compile afterward.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint being edited (the object that will bind the event, e.g. the hub component BP).
target_class	string	yes	The EXTERNAL class that owns the dispatcher. Accepts a Blueprint/widget short name, a full asset path, a full class path (/Game/.../WBP.WBP_C), a native /Script path, or the generated "..._C" class name. Prefer a full path or the "_C" class for reliable resolution.
dispatcher_name	string	yes	The multicast delegate (event dispatcher) property to assign. Matched tolerantly: exact name, spaces stripped, or the display name (so "On Item Selected" resolves to the spaceless FName). On failure the error lists the assignable delegates found on target_class.
event_name	string	no	Optional desired name for the handler custom event; made unique in the Blueprint. Defaults to "<Dispatcher>_Event".
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { blueprint_name, graph_name, target_class, dispatcher, add_delegate_node_id, custom_event_node_id, custom_event_name, wired, node_id, pins:[...] (the AddDelegate node's pins -- wire 'self'/Target = the widget instance and 'execute'/'then' into your exec flow), custom_event:{ node_id, pins:[...] } (hang handler logic off its 'then'/'output_delegate' and read the dispatcher's param output pins) }

add_parent_call_node

Additive.

Add a "Parent: <Function>" node that calls the parent-class implementation of an overridden function/event -- the second half of the child-first shape "Event X -> Parent: X -> our logic" that keeps a vendor base class working while the child adds behaviour. Searches the WHOLE ancestor chain, not just the immediate parent. Does NOT compile, and IS allowed inside build_blueprint_graph, so the event + super + logic can be built in one transaction.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint whose parent function is called
function_name	string	yes	Name of the overridden function/event whose parent implementation to call; must exist on some ancestor or the call errors
graph_name	string	no	Target graph (usually the override's own graph); defaults to the event graph
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[execute, then, the parent's params], blueprint_name, graph_name, function_name, parent_class } -- parent_class names the ancestor that actually declares the implementation being called.

add_reroute_node

Additive.

Add a reroute/knot node: pure layout, it re-emits whatever is wired into it and changes no behaviour. Does NOT compile. Note when reading graphs back: get_graph_nodes with compact=true excludes knots by default, so a chain that looks broken there may simply route through one -- re-read with exclude_classes=[].

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...wildcard in/out until wired...], blueprint_name, graph_name }

add_select_node

Additive.

Create a Select node with the RIGHT NUMBER OF OPTION PINS: pass option_count to grow beyond the built-in 2, or an enum in enum_path so one option pin is generated per enum entry and the Index pin becomes that enum. add_graph_node node_type="select" only ever makes the plain 2-option wildcard version. The response names the index pin, the return pin and every option pin, so the branches can be wired without a follow-up read. Its pins stay WILDCARD until something is connected (connect_pins reconstructs the node to re-type them).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.
option_count	number	no	Optional total number of option pins to end up with (default = the node's built-in 2; capped internally at a safe growth loop). Ignored when an enum drives the index.
enum_path	string	no	Optional enum path/name to drive the Index pin (option pins are then auto-generated per enum entry). An engine enum may live in an unexpected module -- ask the enum itself with static_enum().get_path_name() rather than guessing /Script/Engine.
index_type	string	no	Alias of enum_path (an enum path/name for the Index pin).
position_x	number	no	Node X position (ignored when node_position is set).
position_y	number	no	Node Y position (ignored when node_position is set).
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y.

Returns: { node_id, pins:[...], blueprint_name, graph_name, index_pin, return_value_pin, option_pins:[string], option_count, index_enum? }

add_sequence_node

Additive.

Add a Sequence node that fires its outputs in order, spawned with its default two 'Then 0'/'Then 1' pins (there is no parameter to add more), AND compile the Blueprint. add_graph_node node_type="sequence" makes the same node without compiling -- prefer that inside a build_blueprint_graph batch.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[execute, Then 0, Then 1], blueprint_name, graph_name }

add_timeline_to_blueprint

Additive.

Add a Timeline to an Actor Blueprint: creates BOTH the UTimelineTemplate variable and its UK2Node_Timeline node in one call, sets a fixed length in seconds, compiles, and verifies the template really registered (timeline_created). Actor-derived Blueprints only. It does NOT author curves or tracks -- the node comes with Play/Stop/Reverse inputs and Update/Finished outputs and nothing driven; a requested name already in use is silently uniquified, so wire the RETURNED timeline_name.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor Blueprint.
timeline_name	string	yes	Desired variable name for the timeline; if it is taken, a unique one is generated and returned instead.
length	number	no	Timeline length in seconds (sets fixed-length mode); defaults to 5.0
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, class, title, pins:[...], blueprint_name, graph_name, timeline_name, length, timeline_created, timeline_guid } -- timeline_name is the name ACTUALLY used and timeline_created is a post-compile re-lookup of the template, so false means the variable did not survive.

apply_component_property_overrides

Destructive.

Re-apply N component-property overrides on ONE Blueprint with a SINGLE compile and a SINGLE save, then verify each value against the POST-COMPILE template (what a fresh instance actually reads). ICH-aware exactly like set_blueprint_component_property: an override on a component inherited from an ancestor Blueprint is routed through this class' InheritableComponentHandler. Built for post-reparent re-authoring, where one call per override means N compiles and N chances for an ICH record not to survive.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset path or short name
overrides	array	yes	Array of { component_name, property_name, property_value } objects, applied in the given order
compile	boolean	no	Optional bool (default true). false skips the compile: nothing is verifiable, every entry reports matches_requested=false with verification_status='not_verifiable'
save	boolean	no	Optional bool (default true). Saves the Blueprint package ONCE, after the compile

Returns: { success, error?, data: { blueprint_name, requested_count, applied_count, verified_count, mismatched_count, failed_count, compiled, saved, save_error?, equality_predicate, results: [{ index, component_name, property_name, source, applied, apply_error?, verification_status, matches_requested, post_value, post_source, note? }], verification } }

apply_material_to_blueprint

Destructive.

Assign a material ASSET to one slot of a Blueprint component TEMPLATE (an OWN SCS node, not a placed actor) -- the persistent counterpart of set_mesh_material_color, which only builds a runtime dynamic instance. Does NOT compile and does NOT save. Actors ALREADY placed in a level keep their serialized material: change the template and the placed instances stay as they were.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of an OWN SCS component; must be a UPrimitiveComponent
material_path	string	yes	Asset path of the UMaterialInterface (material or material instance) to assign; a path that does not load is an error
material_slot	number	no	Optional material slot index; defaults to 0. It is not range-checked against the mesh's slot count.

Returns: { blueprint_name: string, component_name: string, material_path: string, material_slot: int, success: bool } -- an echo: success:true only means the material loaded and SetMaterial was called. Read it back with get_blueprint_material_info.

attach_blueprint_component

Destructive.

Parent an existing SCS component under another component (or the native root). The parent may be an SCS component of this Blueprint OR a NATIVE inherited scene component from a parent C++ class (e.g. ACharacter's "CharacterMesh0" or the native capsule) -- when the name is not an SCS node and is not the native root, it is resolved from the parent-class CDO and the child is parented to it natively (bIsParentComponentNative=true). This makes sockets on inherited native meshes reachable (e.g. a socket under CharacterMesh0 at "spine_4", or a ChildActor attached at "spine_2").

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of the SCS component to attach (the child)
parent_component_name	string	no	Optional parent component name; omit / "root" / the native root name attaches to the native root component. May also name a NATIVE inherited scene component (e.g. "CharacterMesh0") to parent the child natively to it.
socket_name	string	no	Optional socket/bone name on the parent (AttachToName)

Returns: { blueprint_name, component_name, parent, parent_is_native, attach_socket, already_attached }

build_blueprint_graph

Destructive.

Build several nodes, wire their pins, and set pin defaults in one pass, wrapped in a single undo transaction -- the way to author a whole graph shape without create -> get_graph_nodes -> connect round-trips (get_function_pins gives you the pin names up front). THE ORDER IS FIXED AND MATTERS: every node first, then ALL connections, then pin_defaults -- so a node whose TYPE depends on a pin default (a generic GetComponentByClass) is connected while still untyped, fails with "... is not compatible with ..." and, under stop_on_error's default true, takes the whole call down; use add_get_component_by_class_node, which is born typed. add_comment_node has no pins at all, so a pin_defaults entry aimed at one also kills the batch. Self-contained: each sub-step runs its command directly, never through the bridge (only these: add_graph_node, add_custom_event_node, add_timeline_to_blueprint, add_cast_node, add_branch_node, add_sequence_node, add_component_bound_event, add_input_action_event_node, add_enhanced_input_action_node, add_actor_begin_overlap_event, add_call_library_function, add_reroute_node, add_comment_node, add_select_node, add_make_struct_node, add_break_struct_node, add_parent_call_node, add_get_component_by_class_node, add_broadcast_node, add_object_bound_event, add_macro_instance_node). add_component_event is NOT usable here; create it with its own call.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
nodes	array	yes	[{id: string, command_type: string, params?: object}, ...] (required, non-empty). 'id' is a caller-chosen local key used to reference the node from 'connections'/'pin_defaults'; 'params' is that command's own param object (blueprint_name/graph_name are auto-filled if omitted). WORKED EXAMPLE (print "hi" on BeginPlay, one call): nodes=[{"id":"beg","command_type":"add_graph_node","params":{"node_type":"event","event_name":"ReceiveBeginPlay"}},{"id":"print","command_type":"add_graph_node","params":{"node_type":"print_string"}}], connections=[{"from_node":"beg","from_pin":"then","to_node":"print","to_pin":"execute"}], pin_defaults=[{"node":"print","pin":"InString","value":"hi"}]. Pin names for a call_function node are knowable up front via get_function_pins (so no create->get_graph_nodes->connect round-trips). Child-override canonical shape (call the parent first), one call: nodes=[{"id":"evt","command_type":"add_graph_node","params":{"node_type":"event","event_name":"ReceiveBeginPlay"}},{"id":"super","command_type":"add_parent_call_node","params":{"function_name":"ReceiveBeginPlay"}}], connections=[{"from_node":"evt","from_pin":"then","to_node":"super","to_pin":"execute"}]. NOTE on add_object_bound_event: it creates TWO nodes; the step's local 'id' resolves to the UK2Node_AddDelegate (wire the external instance into its 'self' pin and the exec flow into 'execute'), while the handler custom event is addressable as "<id>.custom_event" and its real NodeGuid is echoed back as custom_event_node_id.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
connections	array	no	[{from_node, from_pin, to_node, to_pin}, ...]; from_node/to_node may be a local 'id' from 'nodes' (or "<id>.custom_event" for an add_object_bound_event step's handler event) or a pre-existing real NodeGuid.
pin_defaults	array	no	[{node, pin, value}, ...]; node may be a local 'id' from 'nodes' (or "<id>.custom_event") or a pre-existing real NodeGuid.
stop_on_error	boolean	no	Stop (and try to roll back the whole transaction) on the first failing step; defaults to true, unlike batch's default false, since connections/pin_defaults depend on earlier nodes existing. With stop_on_error:false there is NO rollback at all -- the editor's global undo is never touched, every step is attempted, and whatever half-built shape remains is cleaned up with delete_node/disconnect_pin. That is the safer mode when other work is live in the editor's undo buffer.

Returns: { blueprint_name, graph_name, nodes: [{index, id, command_type, ok, node_id?, custom_event_node_id?, error?}], connections: [{index, ok, error?}], pin_defaults: [{index, ok, error?}], stopped_early, rollback_required, rolled_back, transaction_opened, undo_queue_len_before, undo_queue_len_after, top_transaction_title, rollback_refused_reason?, warning? }. rolled_back reports whether the undo ACTUALLY ran, not the intention: the rollback is refused (rolled_back:false + rollback_refused_reason + warning) whenever the top of the editor's undo stack is not this call's own transaction, because GEditor->UndoTransaction is global and would otherwise revert another agent's or another session's work in memory while the disk stays clean. A payload that fails pre-validation returns instead { success:false, error, validation_errors: [{section, index, id?, error}], transaction_opened:false, blueprint_name, graph_name } and never opens a transaction.

compile_blueprint

Destructive.

Compile a Blueprint to regenerate its class, returning the REAL outcome (succeeded == zero errors) plus the error/warning counts, and with return_messages=true the per-message log with each message anchored to its node_id/graph. Required after authoring functions, variables or RPCs and before anything calls them. TRAP: num_errors:0 is not a promise the graph works -- an unresolved WILDCARD pin on an array/ForEach node can compile clean and still block PIE, and warnings (a "was pruned" node whose consumers silently read defaults) do not lower it. Read the warnings too, and get_compile_errors as a second opinion.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint. A short name matching two assets compiles ONE of them silently -- pass the full path when in doubt.
return_messages	boolean	no	Optional (default false). When true, ALSO returns the per-message compiler results log so callers can see node-anchored errors/warnings. When false/absent the response omits the messages array but still reports the REAL compile status.

Returns: { name: string, compiled: bool, succeeded: bool, num_errors: int, num_warnings: int } -- `compiled`/`succeeded` reflect the ACTUAL compile outcome (true iff zero errors; warnings still compile). Both the default and return_messages paths return these fields. When return_messages=true additionally { messages: [{severity: 'error'|'warning'|'note', text: string, node_id: string, node_title: string, graph_name: string}] } (node_id/node_title/graph_name are empty strings when the message is not anchored to a graph node)

connect_pins

Destructive.

Wire one node's OUTPUT pin to another node's INPUT pin inside one Blueprint graph, type-checked by the K2 schema (an incompatible pair is returned as an error, never a silent no-op). Nodes are addressed by NodeGuid, pins by name. Either node that still carries a WILDCARD pin is reconstructed afterwards, so array / ForEach / Select pins really re-type instead of compiling into "The type of Target Array is undetermined" (which compile_blueprint reports as compiled:true). Use validate_pin_connection to test a pair without mutating, and build_blueprint_graph to create+wire in one transaction.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
source_node_id	string	yes	NodeGuid of the source node (from add_graph_node / get_graph_nodes).
source_pin	string	yes	Output pin name on the source node (e.g. "then", "ReturnValue"). An output pin of that name is preferred; any pin with the name is accepted as a fallback.
target_node_id	string	yes	NodeGuid of the target node.
target_pin	string	yes	Input pin name on the target node (e.g. "execute", "Condition").
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted. BOTH nodes must live in this same graph.

Returns: { connected, source_node_id, target_node_id } -- connected is always true when the call succeeds; the failure path is an error response, so there is no false to check.

create_actor_action_utility

Additive.

Create, compile and save a Blueprint parented to UActorActionUtility, whose CallInEditor functions become right-click actions on level actors. An existing Blueprint at the path is returned unchanged, whatever its parent; a failed save only sets saved false. Returns asset_path, created, already_existed and saved. Refused during PIE unless force.

Parameter	Type	Required	Description
package_path	string	yes	Content folder for the asset, e.g. "/Game/EditorTools"; a trailing slash is ignored.
name	string	yes	Asset name without path or extension, e.g. "EUA_AlignToFloor".

Returns: success or error payload

create_asset_action_utility

Additive.

Create, compile and save a Blueprint parented to UAssetActionUtility, whose CallInEditor functions become right-click actions on Content Browser assets. An existing Blueprint at the path is returned unchanged, whatever its parent; a failed save only sets saved false. Returns asset_path, created, already_existed and saved. Refused during PIE unless force.

Parameter	Type	Required	Description
package_path	string	yes	Content folder for the asset, e.g. "/Game/EditorTools"; a trailing slash is ignored.
name	string	yes	Asset name without path or extension, e.g. "EUA_RenameTextures".

Returns: success or error payload

create_blueprint

Additive.

Create a new Blueprint asset, optionally as a child of ANY parent class -- native or another Blueprint (pass its "..._C" class or asset path) -- and save it to disk immediately unless PIE is running. Also makes Blueprint Function Libraries and Macro Libraries, which have no Actor parent and which the normal path would reject. It does NOT create interfaces (create_blueprint_interface) nor the framework-class shortcuts (create_game_mode_class_bp, create_player_controller_class_bp, ...). It refuses instead of overwriting when the asset already exists on disk, and it never confirms the parent: read it back with get_blueprint_parent.

Parameter	Type	Required	Description
name	string	yes	Blueprint name. Either a bare name (created under 'path' or /Game/Blueprints/) OR a full content path ("/Game/MyGame/Systems/World/BP_Foo"); an object-path form ("/Game/.../BP_Foo.BP_Foo") is also accepted.
parent_class	string	no	Optional parent class. Accepts a native name ("Actor", "Pawn", "Character", "StaticMeshActor", "BlueprintFunctionLibrary"), a "/Script/Module.Class" path, a Blueprint generated-class path ("/Game/.../BP_X.BP_X_C"), or a Blueprint asset path ("/Game/.../BP_X"). Defaults to AActor. Passing "BlueprintFunctionLibrary" makes a Function Library.
blueprint_type	string	no	Optional Blueprint type override: "normal" (default), "function_library" (a UBlueprintFunctionLibrary of static functions; parent_class is ignored/forced), or "macro" (a Macro Library; keeps parent_class or defaults to Actor). Function-library is also auto-detected from parent_class="BlueprintFunctionLibrary".
path	string	no	Optional target content folder ("/Game/MyGame/Systems"). Used only when 'name' is a bare name; ignored when 'name' is already a full path.

Returns: { name: string, path: string, package_path: string, parent_class: string, generated_class: string, blueprint_type: string, already_exists: bool, saved: bool, save_error?: string } -- parent_class here is what was REQUESTED and resolved, not proof the asset carries it: confirm a child's real parent with get_blueprint_parent. saved:false is honest and always carries save_error (PIE was running, or the Blueprint was already resident in memory and left untouched) -- an unsaved Blueprint exists only in the editor and a later compile on it also returns success.

create_blueprint_macro

Additive, idempotent.

Create an EMPTY, Tunnel-terminated macro graph owned by this Blueprint's MacroGraphs (a reusable snippet, not a function: macros inline at compile time and can carry multiple exec outputs). Idempotent -- an existing macro of that name is returned with already_existed:true. Fill it with add_graph_node using graph_name=<macro>, then instantiate it with add_macro_instance_node (add_graph_node node_type="macro_instance" also finds the Blueprint's own macros).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
macro_name	string	yes	Name for the new macro graph.

Returns: { blueprint_name, macro_name, graph_name, already_existed } -- graph_name is what to pass as graph_name / macro_graph downstream.

create_editor_utility_blueprint

Additive.

Create, compile and save an Editor Utility Blueprint at package_path/name, parented to parent_class. Returns asset_path, parent_class, created, already_existed and saved; an existing Editor Utility Blueprint there is returned unchanged and parent_class is not applied to it. Refused during PIE unless force.

Parameter	Type	Required	Description
package_path	string	yes	Content folder for the asset, e.g. "/Game/EditorUtilities"; a trailing slash is ignored.
name	string	yes	Asset name without path or extension, e.g. "EUB_BatchRename".
parent_class	string	no	Parent class by name without the U or A prefix, e.g. "EditorUtilityActor", or by path such as "/Script/Blutility.EditorUtilityObject" (default EditorUtilityObject); it must be Blueprintable.

Returns: { name, package_path, asset_path, blueprint_class, parent_class, created, already_existed, saved, save_error }

create_editor_utility_widget_blueprint

Additive.

Create, compile and save an Editor Utility Widget Blueprint (parent UEditorUtilityWidget) with a CanvasPanel root at package_path/name. Returns asset_path, root_widget, root_widget_class, created, already_existed and saved; an existing one is returned unchanged. Open it as a tab with run_editor_utility_widget. Refused during PIE unless force.

Parameter	Type	Required	Description
package_path	string	yes	Content folder for the asset, e.g. "/Game/EditorUtilities"; a trailing slash is ignored.
name	string	yes	Asset name without path or extension, e.g. "EUW_LevelTools".

Returns: { name, package_path, asset_path, blueprint_class, parent_class, root_widget, root_widget_class, created, already_existed, root_created, saved, save_error }

delete_bp_variable

Destructive.

Remove a member variable DECLARED on this Blueprint (inherited/native variables are refused) and report whether it is really gone by re-looking it up. Nodes that still read/write it survive as broken references, so run compile_blueprint + get_compile_errors afterwards. For an event dispatcher use remove_event_dispatcher instead -- this call would drop the delegate variable and strand its signature graph.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
variable_name	string	yes	Name of a variable declared on THIS Blueprint

Returns: { blueprint_name, variable_name, deleted } -- deleted is re-checked after the removal, so false means it is still there.

delete_node

Destructive.

Delete ONE node from a graph by its NodeGuid, breaking its links; refused for nodes the editor protects (FunctionEntry, Result, tunnels). This is the cleanup for orphan nodes left behind when a build_blueprint_graph batch fails and its rollback is refused, and it is reversible (the .uasset on disk is untouched until save_asset). It does NOT compile -- follow with compile_blueprint + get_compile_errors.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
node_id	string	yes	NodeGuid of the node to delete
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { deleted, node_id }

disconnect_pin

Destructive.

Break ALL links on one pin of one node (there is no way to drop a single link of a multi-linked pin). Main use: clearing links that point at nodes which no longer exist after a failed or refused build_blueprint_graph rollback -- get_graph_nodes with compact=false shows those as linked_to entries with dead GUIDs. To remove the whole node instead, use delete_node.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
node_id	string	yes	NodeGuid of the node owning the pin (from add_graph_node / get_graph_nodes)
pin_name	string	yes	Pin name, in either direction
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { disconnected, node_id, pin_name }

find_blueprint_node_references

Read-only.

"Find in Blueprints" over MCP: locate every Blueprint NODE that references a symbol -- variable, function, event, custom event, multicast delegate, macro, timeline, cast target, component, or a class/object in a pin default -- across a content path, returning each hit's asset, graph chain, node_id, title, match_kind and RESOLVED declaring class (resolved:false = a name-only guess). READ-ONLY. THE RULE FOR READING A ZERO: matches_found:0 only measures NON-EXISTENCE when assets_hit_prefilter_without_graph_match comes back EMPTY -- if it names assets, the symbol's string IS in those packages, so either the real name is spelled differently or the reference lives outside a graph (component template, property default). Check coverage_complete too: a truncated, timed-out or capped scan proves nothing. Blind by construction: Level Script Blueprints inside a .umap, and C++ callers.

Parameter	Type	Required	Description
symbol	string	no	Required (unless component_name is given): the name to look for, matched EXACTLY (variable/function/event/macro/class/component name). A misspelling returns 0 with a full-coverage report -- see assets_hit_prefilter_without_graph_match before believing it.
component_name	string	no	Optional: search for an actor COMPONENT by name; implies mode="component" and, with owner_blueprint, also matches GetComponentByClass/Cast pins that target the component's class.
owner_blueprint	string	no	Optional: Blueprint that DECLARES component_name (asset name or path); required to resolve the component's class for the class-pin matching.
mode	string	no	Optional (default "auto"): auto|all|variable|function|event|delegate|macro|component|class|pin_default. Filters which match kinds are returned; an unrecognized value returns everything and sets mode_recognized=false.
path	string	no	Optional (default "/Game"): content path root to scan.
recursive	boolean	no	Optional (default true): recurse into subfolders of path.
exclude_paths	array	no	Optional: array of package-path prefixes to skip (e.g. ["/Game/VendorPack/Demo"]).
include_paths	array	no	Optional: array of package-path prefixes to restrict the scan to (applied after path).
prefilter	boolean	no	Optional (default true): byte-scan the .uasset name map before loading. Turning it OFF loads every Blueprint under path (slow, but the ground truth to compare against).
case_sensitive	boolean	no	Optional (default false): case-sensitive symbol matching (both the byte prefilter and the node classifier).
include_pin_defaults	boolean	no	Optional (default true): also report pin defaults / pin types that name the symbol, on nodes with no structural match.
include_node_json	boolean	no	Optional (default false): embed the full NodeToJson serialization of each matching node.
include_pins	boolean	no	Optional (default false): when include_node_json is on, include the node's pins.
max_assets	number	no	Optional (default 20000): hard cap on candidate assets examined.
max_matches	number	no	Optional (default 200): stop after this many matches (sets truncated=true).
max_seconds	number	no	Optional (default 60): wall-clock budget; on expiry the scan stops and timed_out=true.

Returns: { symbol, mode, mode_recognized, path, recursive, prefilter_enabled, component_class, component_declared_in, assets_in_path, assets_scanned, assets_prefiltered_out, assets_prefilter_unavailable, assets_prefilter_bypassed_dirty, assets_loaded, assets_load_failed, assets_with_matches, graphs_visited, nodes_visited, foreign_subgraphs_skipped, matches_found, truncated, timed_out, coverage_complete, elapsed_ms, assets_hit_prefilter_without_graph_match:[string], notes:[string], matches:[{asset_name, asset_path, package_name, graph, graph_chain, graph_kind, node_id, node_class, node_title, match_kind, member_name, declaring_class, resolved, is_component_ref, is_interface_call, exact, detail, pin, pin_value, node?}], success }

fork_class_chain

Destructive.

One-call thin-fork + optional reparent + verify: collapses the create->reparent->verify pattern into a single call. It creates a NEW thin child Blueprint of base_class at fork_name (the seam you insert between a shared-library base and your own class), optionally tags it with the fork-origin metadata tag (project setting ForkOriginTag), saves it, and then -- only if reparent_target is given -- reparents that existing Blueprint onto the new fork through the guarded reparent_blueprint_safe path (snapshot + compile flags + post-check + rollback) and reports its verification. WARNING: no durable backup is taken -- the rollback is in-memory only, so call backup_asset yourself first if you want a rollback-to-disk safety net.

Parameter	Type	Required	Description
fork_name	string	yes	Name or full /Game path for the NEW thin child Blueprint to create.
base_class	string	yes	Parent class for the new fork (native /Script, /Game/.../BP.BP_C, or a BP asset path).
path	string	no	Optional folder for fork_name when it is a bare name (default /Game/Blueprints).
fork_origin	string	no	Optional: value stored in the fork's fork-origin metadata tag (project setting ForkOriginTag, default 'mcp.forkOrigin'), recording its fork lineage.
reparent_target	string	no	Optional: an existing Blueprint to reparent onto the new fork.
auto_rollback	boolean	no	Optional (default true): forwarded to the safe reparent of reparent_target.
rename_colliding_vars	boolean	no	Optional (default false): forwarded to the safe reparent of reparent_target.

Returns: { fork_name, fork_path, fork_generated_class, base_class, already_exists, fork_origin_set, saved, save_error?, reparent:{...safe-reparent result...}|null, verification, verification_checks, error?, success }

get_actor_material_info

Read-only.

List the material slots of an actor PLACED IN THE EDITOR WORLD, one row per slot per StaticMeshComponent, with the material actually assigned (name, path, class) or "None". Scope limits worth knowing: it only walks UStaticMeshComponents (a skeletal mesh's slots are invisible here) and only the EDITOR world (no PIE selector), and the actor is matched by its object NAME, not its outliner label. The Blueprint-template twin is get_blueprint_material_info.

Parameter	Type	Required	Description
actor_name	string	yes	Object name of the actor in the EDITOR world (GetName(), not the display label shown in the outliner)

Returns: { actor_name: string, material_slots: [{ slot, component, material_name, material_path, material_class }], total_slots: int } -- total_slots 0 means no StaticMeshComponent had slots, NOT that the actor has no materials.

get_ai_perception_senses

Read-only.

Read back the senses configured on an AIPerceptionComponent TEMPLATE of a Blueprint: for each one its config class plus the fields that matter (sight radius / lose-sight radius / peripheral angle, or hearing range) and the three affiliation filters. This is the verification step for add_ai_perception_sense. It reads the OWN SCS template, so an AIPerception component inherited from a parent Blueprint is not found, and a config class other than Sight or Hearing comes back with sense_type "unknown" and no fields.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint owning the component
component_name	string	yes	Name of an OWN SCS AIPerceptionComponent node; another component type is an explicit error

Returns: { blueprint_name, component_name, senses: [ { config_class, sense_type, sight_radius|hearing_range, ... , detect_enemies, detect_neutrals, detect_friendlies } ], sense_count } -- sense_count 0 means the template has no configured sense, which is also what an AI that never perceives anything looks like.

get_available_materials

Read-only.

Enumerate material assets under a content path and return each one's name, object path, package and class -- the object path is what apply_material_to_blueprint / set_actor_material expect. One Asset Registry query on UMaterialInterface and all its subclasses (materials, material instances, project or plugin material classes); nothing is loaded, so a wide path is cheap. For one known name prefer resolve_asset_by_name.

Parameter	Type	Required	Description
search_path	string	no	Optional content path filter (e.g. "/Game/Materials"); empty/absent means the whole project and is reported back as "/Game/"
include_engine_materials	boolean	no	When true, also include /Engine/ materials; defaults to true, so the list is large unless a search_path narrows it

Returns: { materials: [{ name, path, package, class }], count: int, search_path_used: string } -- there is no truncation flag: count is everything that matched.

get_blueprint_component_object_path

Read-only.

Resolve a Blueprint component's TEMPLATE archetype and return its object path, so get_property_value/set_property_value/call_function can target that component directly.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name/path of the Blueprint that owns the component.
component_name	string	yes	Component variable name. Resolves an OWN SCS component (the _GEN_VARIABLE archetype on USCS_Node::ComponentTemplate) or an INHERITED/native component (the like-named subobject on the generated-class CDO).

Returns: { object_path: string, class: string, source: 'scs'|'inherited' } -- object_path is GetPathName() (feed it to get/set_property_value); class is the component class' full path.

get_blueprint_component_property

Read-only.

Read the EFFECTIVE default of a property on a Blueprint component TEMPLATE, resolving components INHERITED from a parent/grandparent Blueprint. Read-only twin of set_blueprint_component_property: it NEVER mints an ICH override. Resolution order: own SCS template -> existing child InheritableComponentHandler override -> ancestor's declaring SCS template -> native CDO subobject. Omit property_name to dump ALL properties of the resolved template.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset path or short name
component_name	string	yes	Component variable name (own or inherited)
property_name	string	no	Property to read; omit to return ALL properties of the resolved template
include_inherited	boolean	no	Also resolve inherited/ICH/native components (default true); when false only this Blueprint's own SCS components are considered
group_by_field	string	no	Optional. Only with property_name pointing at a TArray of STRUCTS: group the elements by this struct member and report duplicate_groups[]/empty_key_indices[]/has_duplicates. Two elements sharing a key is invisible in a plain value dump, yet when that array feeds a TMap the LAST one silently wins (Map.Add overwrites) -- this is the guardrail for exactly that class of bug.
report_duplicates	boolean	no	Optional bool. Implied true when group_by_field is given; pass true WITHOUT group_by_field to group by the WHOLE element value instead of one member.

Returns: { blueprint_name: string, component_name: string, component_class: string, source: 'scs'|'inherited-ich'|'inherited-scs'|'inherited-native', resolved_from_class: string, property_name: string, value: any (single-property mode), properties: object, property_count: int (all-properties mode), duplicate_analysis?: { grouped_by, element_count, distinct_keys, duplicate_groups: [{key, count, indices[]}], empty_key_indices: [int], has_duplicates: bool, keys: [string] } }

get_blueprint_components

Read-only.

List the components this Blueprint DECLARES in its own SCS, with type, relative transform and the real hierarchy linkage (in-tree parent from the ChildNodes tree, parent_is_native for a native/inherited parent, attach_socket, children). SCOPE: own SCS only -- components inherited from a parent Blueprint or declared natively are NOT here, so a small count is not proof the actor is small. For the full picture including ancestors use get_blueprint_scs_tree (which reports what it deduplicates), and cross-check the CDO when a component must be proven to exist.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint

Returns: { blueprint_name: string, components: [{ name, type, is_scene_component, parent, parent_is_native, attach_socket, children:[name], location?, rotation?, scale? }], component_count: int } -- "parent" is the in-tree SCS parent, falling back to the inherited/native parent name when the node is parented outside this SCS; location/rotation/scale only appear for scene components.

get_blueprint_functions

Read-only.

List the callable graphs of a Blueprint. Enumerates the FULL graph set (UBlueprint::GetAllGraphs), not just Blueprint->FunctionGraphs: an INTERFACE override graph lives in ImplementedInterfaces[].Graphs, which FunctionGraphs alone misses (a function that exists would read as "missing"). Each entry carries graph_type so the caller can tell a plain function from an interface override, a macro or a delegate signature.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint. Pass the FULL path: a short name that matches two assets (a backup copy shares the original's name) resolves to one of them SILENTLY, and the listing then describes the wrong asset.
include_ubergraphs	boolean	no	Optional bool (default false): also list the EventGraph/ubergraph pages (graph_type='ubergraph'). Off by default so 'functions' stays function-shaped.
include_subgraphs	boolean	no	Optional bool (default false): also list nested/collapsed sub-graphs reached by GetAllGraphs but owned by no top-level list (graph_type='subgraph')

Returns: { blueprint_name: string, functions: [{ name, node_count, graph_type, is_interface, interface_name?, is_user_constructed }], function_count: int, own_function_graph_count: int, interface_graph_count: int, macro_graph_count: int, delegate_graph_count: int, ubergraph_count: int, subgraph_count: int, graphs_total: int } -- graph_type is function|interface|macro|delegate_signature|ubergraph|subgraph; is_user_constructed is just node_count>2, i.e. "someone wrote something beyond the auto Entry/Result terminators", because implementing an interface pre-creates empty graphs. subgraph_count>0 with include_subgraphs off is the warning that collapsed graphs exist and are not listed.

get_blueprint_info

Read-only.

One cheap overview of a Blueprint: parent class, compile status, and the counts + names of its OWN components, variables, function graphs and ubergraph pages. Everything here is what THIS asset declares -- nothing inherited, and interface-override graphs are not listed. So use it to orient, and the specialists to decide: get_blueprint_scs_tree for the real component set including ancestors, get_blueprint_functions for interface/macro/delegate graphs, get_blueprint_variables for variable flags, get_graph_nodes to read a graph.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint

Returns: { blueprint_name: string, parent_class: string, components: [{ name, type }], component_count: int, variables: [{ name, type }], variable_count: int, functions: [{ name }], function_count: int, graphs: [{ name, type }], graph_count: int, has_event_graph: bool, event_graph_name?: string, status: string } -- parent_class is a short NAME (ambiguous between an engine class and a same-named project one), variable "type" is only the pin CATEGORY (no struct/class), and status is UpToDate/Error/Unknown.

get_blueprint_material_info

Read-only.

Read the material slots of ONE StaticMeshComponent TEMPLATE in a Blueprint (an OWN SCS node), with the material assigned to each slot or "None". This is the verification step after apply_material_to_blueprint / set_static_mesh_properties. The slot count comes from the assigned static mesh's LOD 0 sections, so with no mesh assigned it returns ZERO slots and has_static_mesh:false -- which is a missing mesh, not a missing material. For a placed actor use get_actor_material_info.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of an OWN SCS component; it must be a UStaticMeshComponent (any other type is an error)

Returns: { blueprint_name: string, component_name: string, material_slots: [{ slot, component, material_name, material_path, material_class }], total_slots: int, has_static_mesh: bool } -- read has_static_mesh FIRST: total_slots:0 with has_static_mesh:false means no mesh was assigned, so the array says nothing about materials.

get_blueprint_variable_detailed_info

Read-only.

Read ONE variable's full detail: its default value, the structured type (category, sub-category object and container kind -- not just the pin category get_blueprint_variables gives you), and every checkbox of the variable Details panel -- is_instance_editable / is_expose_on_spawn / is_blueprint_read_only / is_expose_to_cinematics / is_replicated / replication_condition / save_game. This is the headless oracle for "does this variable really persist into a .sav?", which otherwise costs a co-op PIE session plus a binary grep of the slot file. save_game is reported from BOTH places the flag lives, because they disagree until you compile: save_game is CPF_SaveGame as AUTHORED (FBPVariableDescription::PropertyFlags, exactly what the editor checkbox writes) while save_game_generated is the same flag on the FProperty of the GENERATED class, which is the one the save archive consults -- so save_game:true + save_game_generated:false means MARKED BUT NOT COMPILED, and nothing will persist yet; save_game_matches says it in one field. Read is_replicated FIRST: replication_condition is always populated (COND_None by default) and only means anything when replication is on. default_value is read from the CDO when the class is compiled (default_value_source:"cdo"), so it does not come back EMPTY for arrays, maps and every variable of an already-compiled Blueprint. Booleans of this family are contrasted, not believed -- audit_replication is the ground truth for replication.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
variable_name	string	yes	Name of a variable DECLARED on this Blueprint (e.g. "MyFloat"); inherited variables are not covered

Returns: { blueprint_name: string, variable_name: string, default_value: string, default_value_source: "cdo"|"blueprint_description", default_value_serialized: string, var_type: string, property_type: string, var_type_detail: {category, sub_category, sub_category_object, sub_category_object_path, container}, is_instance_editable: bool, is_expose_on_spawn: bool, is_blueprint_read_only: bool, is_expose_to_cinematics: bool, is_replicated: bool, replication_condition: string, save_game: bool, save_game_generated: bool, save_game_generated_found: bool, save_game_matches: bool }

get_blueprint_variables

Read-only.

List the variables this Blueprint DECLARES (its NewVariables): name, pin category, editor category and three flags. Inherited variables, function locals and components are NOT here. THE THREE FLAGS ARE UNRELIABLE, read off the stored variable description rather than the compiled property: instance_editable checks CPF_Edit and ignores CPF_DisableEditOnInstance, so it says true for variables the editor refuses to edit per instance; expose_on_spawn checks a property flag while set_bp_variable_metadata writes the ExposeOnSpawn METADATA, so it says false for variables that DO show up as SpawnActor pins; and expose_to_cinematics is hardcoded false. Oracles: write the placed instance for editability, the spawn node's pins for exposure, get_blueprint_variable_detailed_info for type/replication.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint

Returns: { blueprint_name: string, variables: [{ name, type, category, instance_editable, expose_on_spawn, expose_to_cinematics }], variable_count: int } -- "type" is only the pin CATEGORY (e.g. "struct", "object"), not the struct or class; the three booleans are the unreliable ones described above.

get_event_dispatchers

Read-only.

List a Blueprint's event dispatchers (multicast delegates) WITH each one's full parameter signature (name, C++ type, is_output) and whether it is inherited. Read from the SKELETON class, so it reflects edits made since the last full compile. Use it before add_broadcast_node / add_object_bound_event / set_event_dispatcher_signature, whose pins mirror this signature; only the dispatchers this Blueprint DECLARES can have their signature edited.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
include_inherited	boolean	no	Also include dispatchers inherited from parent classes; default false = only the ones this Blueprint declares (i.e. the editable ones)

Returns: { blueprint_name: string, dispatchers: [ { name: string, is_inherited: bool, param_count: int, params: [ { name: string, type: string, is_output: bool } ] } ], dispatcher_count: int }

get_function_pins

Read-only.

Preview the EXACT pins a call_function / add_call_library_function node WOULD expose for a UFunction WITHOUT creating anything: owner_class, is_pure, is_static, exec_input/exec_output ("execute"/"then", null when pure), self_pin (null when static), input_params, output_params and return_value. This is what lets a whole build_blueprint_graph (nodes + connections + pin_defaults) be written in ONE call instead of create -> get_graph_nodes -> connect round-trips. It answers "what pins would it have", NOT "can a Blueprint call it": some engine functions resolve and preview here and are still rejected by the compiler, so the oracle for callability is compile_blueprint + get_compile_errors.

Parameter	Type	Required	Description
function_name	string	yes	UFunction name, matched EXACTLY against the reflected name (e.g. "PrintString", "K2_GetActorLocation", or a Blueprint function graph's own name, which may contain spaces like "Emit Noise At Location"). A guessed name that does not exist just errors -- it never returns an empty preview.
target_class	string	no	Optional class searched FIRST: native name ("KismetSystemLibrary"), "/Script/Module.Class", a Blueprint class path ("/Game/...X_C"), or a user BFL. Also always searched: the blueprint's own class + KismetSystem/GameplayStatics/KismetMath.
blueprint_name	string	no	Optional Blueprint whose generated class joins the search (for self / BP-local functions).

Returns: { function_name, owner_class, is_pure, is_static, exec_input, exec_output, self_pin, input_params:[{name,type}], output_params:[{name,type}], return_value:{name,type}|null, note }

get_graph_nodes

Read-only.

Read one Blueprint graph: every node with its node_id (NodeGuid), class, title, position, comment and pins (name, direction, type, linked_to, default) -- the read that feeds connect_pins / set_pin_default_value / delete_node, and the way to see what a graph actually DOES. TRAP: compact=true drops per-pin type metadata AND omits every pin that is unlinked and default-less (plus knots and comment boxes), so a pin missing from a compact listing is NOT proof the pin does not exist -- re-read with compact=false before concluding anything about pins. Also: a bare blueprint_name that matches two assets picks one silently (pass the full path), and reading a graph under a read-only vendor root leaves that package DIRTY in memory (reload_asset_package with on_dirty="discard" cleans it).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path. Prefer the FULL path: a short name with more than one match resolves silently to one of them, and stale backup copies share the original's name.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted. Also resolves a collapsed composite subgraph by its title (e.g. 'In Game HUD') and accepts a path form ('EventGraph > In Game HUD').
expand_composites	boolean	no	When true, inline the nodes of collapsed composite subgraphs recursively; each node gains a "graph" tag naming the graph it came from. Macro-library graphs are never inlined. (Optional, default false)
compact	boolean	no	Token-lean listing: drops pin types, positions and comments, and skips pins that are unlinked AND have no default. Also excludes K2Node_Knot + EdGraphNode_Comment unless exclude_classes is given. Good for reading topology, WRONG for checking whether a pin exists. (Optional, default false)
exclude_classes	array	no	Array of leaf node class names to skip, matched against each node's "class" field (e.g. ["K2Node_Knot"]). Pass [] to include everything even in compact mode. Absent + compact=true means knots and comments are excluded; absent + compact=false excludes nothing.
max_nodes	number	no	Cap on the number of nodes emitted (<=0 or absent = unlimited); the response still counts every non-excluded node in total_node_count and sets truncated=true.

Returns: { blueprint_name, graph_name, nodes:[{node_id, class, title, pos_x, pos_y, comment, pins:[...], subgraph?}], node_count, compact, total_node_count, excluded_count, truncated } -- node_count is what was EMITTED, total_node_count what exists; a node owning a nested graph (composite / macro instance) carries "subgraph" with the name to pass back as graph_name.

get_node_pin_info

Read-only.

Dump ONE node's full pin detail -- every pin's name, direction, type, linked_to and default -- plus its class, title, position and comment, addressed by NodeGuid. Use it instead of get_graph_nodes when the node is already known: the listing is always FULL fidelity (get_graph_nodes with compact=true hides unlinked default-less pins) and costs a fraction of the tokens of a whole graph.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
node_id	string	yes	NodeGuid of the node (from add_graph_node / get_graph_nodes)
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted. Also resolves collapsed composite subgraphs by title or a path form ('EventGraph > In Game HUD').

Returns: { node_id, class, title, pos_x, pos_y, comment, pins:[{name, direction, type, linked_to, default}] }

get_property_access_path

Read-only.

Read a UK2Node_PropertyAccess node's binding Path -- the anim-Blueprint property binding (InAnimInstance.Foo, InDeltaTime...) that no ordinary pin read exposes -- as segments plus its display text_path, and say whether the leaf actually RESOLVED (a still-wildcard Value pin means the path points at nothing). Read-only; errors on any node that is not a K2Node_PropertyAccess. Writer twin: set_property_access_path.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path (usually an Animation Blueprint).
node_id	string	yes	NodeGuid of the property-access node (from get_graph_nodes).
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.

Returns: { node_id, graph_name, path:[string], text_path, resolved, resolved_pin:{name,direction,type,...} } -- resolved:false (Value pin still wildcard) is the signal that the binding is broken.

implement_interface

Destructive.

Add a Blueprint Interface to a Blueprint's implemented list (asset path or class name). NOT idempotent: an interface already implemented comes back as an error, unlike remove_interface. It only registers the contract -- the graphs that IMPLEMENT each member are created by implement_interface_function / override_interface_member, which are also the only correct route for interface EVENTS.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
interface_path	string	yes	Blueprint interface asset path (e.g. /Game/Dir/BPI_Foo.BPI_Foo), or a resolvable interface class name/path

Returns: { blueprint_name, interface, implemented } -- implemented is always true on success; failure is an error response. Confirm the member set with get_blueprint_functions (interface graphs live in ImplementedInterfaces, not FunctionGraphs).

implement_interface_function

Destructive, idempotent.

Create or resolve the graph that IMPLEMENTS an interface member (or a parent virtual) and return a graph_name you can immediately wire with get_graph_nodes / connect_pins / set_pin_default_value. It picks the right shape by itself: a member WITH a return value gets a real FUNCTION graph in ImplementedInterfaces[].Graphs -- where add_blueprint_function refuses it ("Function already exists") and an event node would be a useless return-less stub -- while an event-shape member (no return value) gets a genuine event OVERRIDE node in the event graph, with its node_id returned. Idempotent in both branches. override_interface_member is the same logic under a friendlier name/response.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path (must already implement the interface / inherit the virtual; implement_interface first).
function_name	string	yes	Name of the interface or overridable function (e.g. "CanInteract", "GetInteractText").

Returns: { blueprint_name, function_name, graph_name, kind: "function"|"event", already_existed: bool, node_id? } -- kind "function": graph_name is an editable function graph, ready to wire with get_graph_nodes / connect_pins; kind "event": the member returns nothing, so an event OVERRIDE node was created (or reused) in the event graph that graph_name names, and node_id is that node, to wire with connect_pins.

lint_blueprint_graph

Read-only.

Read-only lint of a Blueprint's graphs for four authoring bugs that COMPILE CLEAN and only show up in play: eclipsed_interface_event and custom_event_shadowing_override (a node that looks like an override and is not, so the base contract never runs), unreachable_exec_node (a node no exec chain reaches from any entry) and function_exit_without_return (a live exec path that falls off the end of a value-returning function, so the caller silently gets false/0/None). Scans ALL ubergraph + function + macro graphs by default. HONESTY LIMIT: findings:[] is NOT a clean bill of health -- by deliberate design it never flags a merely unconnected exec output, so a Branch or Is Valid with dangling outputs can pass; check linked_to yourself with get_graph_nodes (compact=false) or get_node_pin_info.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint to analyze.
graph_name	string	no	Optional single graph to analyze; when omitted, scans ALL ubergraph (event) pages + function graphs + macro graphs owned by this Blueprint. Interface-override graphs are NOT in that default set -- name one explicitly to lint it.

Returns: { findings: [ { kind, node_id, node_title, graph_name, why, fix_hint, pin? } ] } -- kind is one of eclipsed_interface_event, custom_event_shadowing_override, unreachable_exec_node, function_exit_without_return (this one also reports the offending exec pin in "pin"); "why" carries a best-effort pointer at the likely upstream break. No counters and no coverage flags: an empty array only means these four rules found nothing.

list_editor_utility_widgets

Read-only.

List the Editor Utility Widget Blueprint assets under a content folder and its subfolders, read from the Asset Registry without loading them. Returns search_path, count and widgets [{name, asset_path, package_name, package_path}]; open one as an editor tab with run_editor_utility_widget.

Parameter	Type	Required	Description
path	string	no	Content folder to search recursively, without a trailing slash, e.g. "/Game/EditorUtilities" (default /Game).

Returns: { name, asset_path, package_name, package_path, search_path, count, widgets }

list_overridable_functions

Read-only.

Enumerate the functions/events that a Blueprint deriving from a class could override. Works on an EXISTING Blueprint (blueprint_name) or on ANY class (class_name) so the override surface can be inspected BEFORE the child exists. Gated with UEdGraphSchema_K2::CanKismetOverrideFunction -- the same predicate add_blueprint_function(override=true) enforces -- so discovery and authoring agree (a bare NativeEvent||FUNC_BlueprintEvent filter lets a parent Blueprint's *__DelegateSignature through as "overridable"). Each entry reports where the member is DECLARED and where it is last IMPLEMENTED, with is_stub, which is what distinguishes a concrete ancestor from its _Abstract sibling.

Parameter	Type	Required	Description
blueprint_name	string	no	Name/path of an existing Blueprint. Its ParentClass is the override surface.
class_name	string	no	Alternative to blueprint_name: any class ("Actor", "/Script/Engine.Pawn", "/Game/.../BP_X.BP_X_C", or a Blueprint asset path). The override surface is THAT class, i.e. what a new child would get. Ignored when blueprint_name is given.
include_non_overridable	boolean	no	Optional bool (default false). true also lists the entries a NativeEvent||FUNC_BlueprintEvent filter passes but CanKismetOverrideFunction rejects (delegate signatures, BlueprintInternalUseOnly, deprecated), each flagged can_kismet_override=false. Nothing is lost silently.

Returns: { blueprint_name?, class_name?, source_mode, resolved_class, base_class, ancestors: [string], count, functions: [{ function_name, display_name, declaring_class, is_native_event, is_event, is_interface, interface_name?, kind, can_kismet_override, has_override_graph, has_user_logic, is_implemented, parent_impl_kind, parent_impl_owner_class, parent_impl_graph, parent_impl_node_count, is_stub, is_stub_basis }] }

list_scripted_action_utilities

Read-only.

List Editor Utility Blueprints that are scripted Asset/Actor Action Utilities

Parameter	Type	Required	Description
path	string	no	Optional content path to search under (default /Game)

Returns: { name, path, package_name, kind, parent_class, search_path, count, utilities }

list_widget_bound_events

Read-only.

List every event-dispatcher BINDING wired in a Blueprint, across the three node kinds that make one in practice: UK2Node_AddDelegate (from add_object_bound_event / add_graph_node node_type="add_delegate"), UK2Node_ComponentBoundEvent (from add_component_bound_event -- a component's dispatcher OR a UMG widget's, e.g. a Button's OnClicked) and UK2Node_ActorBoundEvent (a level actor's, bound from the Level Blueprint). Each entry reports which kind it is (binding_kind), what it is bound ON (bound_to: the component/widget variable, or the actor), the delegate's owner class and name, and the handler on the other end. Despite the name it works on ANY Blueprint -- but it only walks Ubergraph pages and FunctionGraphs, so a binding inside a macro or interface graph is out of scope. Run it BEFORE add_object_bound_event / add_component_bound_event: double-binding one delegate to two handlers compiles fine and silently runs BOTH. A reader that cannot see what the writer wrote is worse than no reader: a 0 reads as "not wired" and sends you to re-wire what is already there.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path (Actor Blueprint, Widget Blueprint or Level Blueprint).

Returns: { blueprint_name, bindings:[{ graph_name, node_id, binding_kind, bound_to, delegate_owner_class, delegate_name, delegate_resolved, wired, custom_event_name, custom_event_node_id }], binding_count, kind_counts:{add_delegate,component_bound_event,actor_bound_event} } -- binding_kind names the node class behind the entry. bound_to is the component/widget variable name (component_bound_event), the actor name (actor_bound_event), or empty for add_delegate, whose target pin is left unconnected by design. delegate_resolved=false means the delegate no longer resolves live (renamed/removed). wired=false is a DANGLING add_delegate bind (its Delegate pin has no handler); the two *BoundEvent kinds ARE their own handler, so they are always wired and custom_event_name is the generated BndEvt__ function.

move_node

Destructive.

Move a node to a new [x, y] canvas position. Purely cosmetic layout: no pin, link, default or type changes, and no compile. Returns the position actually applied.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
node_id	string	yes	NodeGuid of the node to move
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted
position_x	number	no	Node X position on the graph canvas (ignored when node_position is set)
position_y	number	no	Node Y position on the graph canvas (ignored when node_position is set)
node_position	array	no	Node canvas position as [x, y]; takes precedence over position_x/position_y

Returns: { node_id, pos_x, pos_y }

override_interface_member

Destructive, idempotent.

Override a Blueprint interface member or parent virtual by name: an event override node (kind="event", node_id) when it returns nothing, else a function-override graph (kind="function", graph_name). Idempotent (was_already_overridden); leaves the Blueprint needing a compile, unsaved. Prefer it to hand-placed interface event nodes, which can compile yet never fire.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path (must implement the interface / inherit the virtual).
member_name	string	yes	Name of the interface or overridable function to override (e.g. "CanInteract").
interface_path	string	no	Ignored: the member is resolved by member_name alone, implemented interfaces first, then parent classes.
node_position	any	no	Optional [x, y] canvas position applied to a freshly created event-override node.
position_x	number	no	Ignored by this tool: the new node is only moved when node_position is given, and node_position then wins.
position_y	number	no	Ignored by this tool: the new node is only moved when node_position is given, and node_position then wins.

Returns: { kind: "event"|"function", created: bool, was_already_overridden: bool, graph_name, node_id? } -- kind "event": an event OVERRIDE node was created or reused in the event graph that graph_name names, and node_id is that node; kind "function": graph_name is an editable function-override graph, ready to wire.

recombine_blueprint_pin

Destructive.

Collapse a previously split struct pin back into ONE pin (inverse of split_blueprint_pin), which is what set_pin_default_value needs before it will write a struct literal. Accepts either the parent pin's name or any of its sub-pin names; links on the sub-pins are dropped by the engine as part of recombining.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
node_id	string	yes	NodeGuid of the node owning the pin.
pin_name	string	yes	Name of the parent pin OR of any of its sub-pins.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { recombined } -- always true on the success path; a pin that is not split is an error response instead.

reconcile_function_signature

Destructive.

Repair a LOCAL function graph's parameter pins so they match a parent UFUNCTION -- for an override whose signature went stale after a reparent -- WITHOUT nuking the graph's downstream nodes, which is what re-creating the override by hand costs you. It diffs the parent's parameters against the function's entry/result pins: mode='add_missing' (the default) only ADDS the missing pins, so it is non-destructive and safe to run blind; mode='remove_extra' / 'mirror' also DROP pins the parent lacks, which can sever downstream connections, and are therefore gated behind force_remove=true -- without it the extra pins are merely REPORTED (partially_implemented=true).

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path owning the function.
function_name	string	yes	Name of the local function graph to reconcile.
parent_class	string	no	Optional: class whose UFUNCTION defines the target signature (default: the Blueprint's current ParentClass).
mode	string	no	Optional (default 'add_missing'): 'add_missing' | 'remove_extra' | 'mirror'.
force_remove	boolean	no	Optional (default false): actually remove extra pins for 'remove_extra'/'mirror' (may drop connections).

Returns: { blueprint_name, function_name, parent_class, mode, added:[{name,direction}], removed:[{name,direction}], extra_pins:[{name,direction}], missing_pins:[{name,direction}], removal_performed, partially_implemented, note, success }

remove_blueprint_component_node

Destructive, idempotent.

Remove one or MORE SCS component nodes in a single batch (ONE compile for the whole lot), optionally promoting their children, and report the double census (flat AllNodes vs a walk of RootNodes) so descendants that go missing or become unreachable are NAMED instead of silently dropped. Same engine work as remove_component_from_blueprint; the difference is the contract for a component that is not there: this one is IDEMPOTENT (already_removed:true, no error), while remove_component_from_blueprint treats "nothing matched" as a caller error. Prefer this one in scripts that may re-run.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	no	Name of the SCS component node to remove (single form)
component_names	array	no	Optional array of SCS component node names removed in ONE batch with a SINGLE compile. Chaining single-node calls is what causes collateral deletions; prefer this for lots. Merged with component_name when both are given.
promote_children	boolean	no	Optional bool (default true); true keeps descendants (RemoveNodeAndPromoteChildren), false orphans/deletes them (RemoveNode)

Returns: { success, error?, data: { blueprint_name, component_name, promote_children, removed, already_removed, requested[], removed_components[], also_removed[], unexpected_losses[], not_found[], still_present[], node_count_before, node_count_after, reachable_before, reachable_after, orphans_before[], orphans_after[], root_nodes_before[], root_nodes_after[], root_nodes_changed, compiled, compile_count, verification } }

remove_blueprint_function

Destructive.

Delete a function graph OWNED BY the Blueprint (Blueprint->FunctionGraphs) by name. WARNING: It resolves more graphs than it can delete: name lookup goes through FindGraph (all graphs, interface overrides and macros included) but the delete only touches FunctionGraphs and only when bAllowDeletion is true, so an INTERFACE OVERRIDE resolves and cannot be removed. That case is a hard error naming the reason -- to change an interface override, author the signature on the INTERFACE and re-create it (add_function_parameter on the BPI_ -> compile_blueprint -> implement_interface_function). Not idempotent: a name that does not resolve is an error. TRAP when deleting to re-create: the class is NOT regenerated here, so an immediate add_blueprint_function with the same name fails with "is an inherited overridable function (declared on <this very class>)" because the stale UFunction is still in the generated class -- put a compile_blueprint BETWEEN the two calls. Callers of the removed function are left broken until the next compile.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
function_name	string	yes	Name of the function graph to remove; must exist, be owned by this Blueprint and be deletable, or the call errors

Returns: { blueprint_name: string, removed_function: string, success: bool } -- success:true means the graph is gone from Blueprint->FunctionGraphs (re-read after the delete), not merely that the call ran.

remove_component_from_blueprint

Destructive, idempotent.

Remove one or more component nodes from a Blueprint's SCS, with a DOUBLE CENSUS (flat AllNodes vs a walk of RootNodes) so collateral losses are reported instead of hidden: also_removed names descendants that went with their parent and unexpected_losses names nodes left in AllNodes but unreachable from any root. Batch-capable and that is the point -- chaining SINGLE-node calls on the same Blueprint is exactly the pattern that deletes components nobody asked for, so pass component_names and take ONE compile for the lot. A re-added component comes back with its CLASS defaults: per-instance overrides are gone and do not come back on save. "Nothing matched" is an ERROR here; remove_blueprint_component_node is the idempotent twin that reports already_removed instead.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name/path of the blueprint
component_name	string	no	Name of the component to remove (single form; matches the variable name or the _GEN_VARIABLE internal name)
component_names	array	no	Optional array of component names removed as ONE batch with a SINGLE compile. Chaining single-node calls is the pattern that causes collateral deletions. Merged with component_name when both are given.
promote_children	boolean	no	Optional bool, default true: keep descendants by re-parenting them (RemoveNodeAndPromoteChildren). Pass false for plain RemoveNode, which orphans the whole subtree.

Returns: { success, error?, data: { blueprint_name, removed_component, requested[], removed_components[], also_removed[], unexpected_losses[], not_found[], still_present[], node_count_before, node_count_after, reachable_before, reachable_after, orphans_before[], orphans_after[], root_nodes_before[], root_nodes_after[], root_nodes_changed, promote_children, compiled, compile_count, success, verification } }

remove_event_dispatcher

Destructive, idempotent.

Remove an event dispatcher, dropping BOTH artifacts add_event_dispatcher created: the delegate member variable AND its signature graph (delete_bp_variable removes only the variable and strands the graph, which is why this exists). Idempotent -- when neither artifact is present it returns removed:false instead of erroring. Broadcast/bind nodes that referenced it are left broken: compile_blueprint + get_compile_errors after.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
dispatcher_name	string	yes	Name of the event dispatcher to remove (must be one this Blueprint owns; inherited ones have no local artifacts)

Returns: { blueprint_name, dispatcher_name, removed } -- removed:false means nothing was there (no-op), not a failure.

remove_interface

Destructive, idempotent.

Remove an implemented Blueprint Interface (inverse of implement_interface) and, unless preserve_functions is set, DELETE the graphs that implemented it -- work is lost, so pass preserve_functions=true to keep them as ordinary Blueprint functions. Idempotent, unlike implement_interface: an interface that is not implemented returns removed:false instead of erroring.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
interface_path	string	yes	Blueprint interface asset path (or class name) to remove
preserve_functions	boolean	no	When true, keep the interface's function graphs as normal Blueprint functions instead of deleting them; defaults to false

Returns: { blueprint_name, interface, removed } -- removed:false means it was not implemented (no-op), not a failure.

remove_unused_variables

Destructive.

Delete EVERY variable the engine considers unused from a Blueprint in one shot (GatherUnusedVariables + RemoveUnusedVariables) and report which ones went. Destructive and non-selective -- "unused" means no graph node reads or writes it, so a variable only touched from C++, a DataTable, a save game or a runtime name lookup counts as unused and is deleted. Preview it by comparing get_blueprint_variables before/after, or delete a specific one with delete_bp_variable.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint

Returns: { blueprint_name: string, removed_count: int, removed_variables?: [string] } -- removed_variables is the list gathered BEFORE the removal and removed_count what the engine reported removing; when they disagree, trust neither and re-read get_blueprint_variables.

rename_bp_variable

Destructive.

Rename a member variable DECLARED on this Blueprint, KEEPING everything the delete+re-add workaround throws away: the VarGuid, the type, the default value, the category, the tooltip and the replication flags -- and, crucially, RE-WIRING every Get/Set node that reads it, in this Blueprint and in every dependent one. This is the only correct way to rename an authored variable in place (e.g. to translate its name). WARNING: it refuses a variable that has a RepNotify function: the engine's own rename opens a MODAL dialog for that case (FSuppressableWarningDialog, which does NOT honour unattended mode) and would hang the editor waiting for a click -- clear the RepNotify with set_bp_variable_replication, rename, then set it back. WARNING: dependent Blueprints are only repaired if they are LOADED: this command loads the ones the Asset Registry reports as referencers first, and reports them in referencers_loaded, but an asset that references it in a way the registry does not see keeps the old name silently. It does NOT create CoreRedirects, so a saved game, a DataTable cell or a Python set_editor_property that names the variable as text is NOT fixed -- grep for those. Run compile_blueprint afterwards and save_asset on this Blueprint AND on every referencer.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path owning the variable.
old_name	string	yes	Current name of a variable declared on THIS Blueprint; inherited/native ones are refused.
new_name	string	yes	New name. Must be a legal identifier and free across the WHOLE class chain (the engine does not check this and would happily create a duplicate). Case-only changes are allowed.
load_referencers	boolean	no	Optional bool (default true). Load the Blueprints the Asset Registry lists as referencers BEFORE renaming, so the engine's reference fixup reaches them; it only ever sees what is already in memory.

Returns: { blueprint_name, old_name, new_name, renamed (re-read: true only if new_name exists and old_name is gone), referencers_loaded: [string], repnotify_cleared: bool, warning? }

rename_function_parameter

Destructive.

Rename a PARAMETER of a Blueprint function graph -- the parameter counterpart of rename_bp_variable, and the only headless way to do it: add_function_parameter only ADDS, there is no remove_function_parameter, so "delete and re-add" is not even available. It renames the pin on the Entry node and on EVERY Result node of the graph, and registers a CoreRedirect so that call sites re-map themselves. That redirect is not a nicety: it is what stops this from being a PHANTOM PIN FACTORY. With the redirect, the call site's pin takes the new name AND KEEPS ITS LITERAL VALUE; renamed WITHOUT one, the old pin stays alive and ORPHANED on the caller. WARNING: that orphan is silent: it survives compiles that report num_errors:0 -- so compile_blueprint is NOT the oracle here. The oracle is get_graph_nodes(compact=false) on the callers, checking that NO pin still carries the old name. The redirect matches on Class.Function.Param, so it reaches callers that merely CALL the function (K2Node_Message included) without implementing its interface, and dependents that are not even loaded -- both of which rename_bp_variable cannot reach. It does NOT rename anything that names the parameter as TEXT (a DataTable cell, a saved game, Python). Run compile_blueprint afterwards and save_asset on this Blueprint AND on every caller. AND THE COMPILE IS NOT THE END OF IT: what reaches the .uasset is UserDefinedPins, not the EdGraphPins you read back -- a rename checked only on the latter can report renamed:true, compile at num_errors:0, be saved and COMMITTED, and still come back as the OLD name the next time the editor starts. So it also reports entry_user_pins_after/result_user_pins_after (the serialized side, legitimately EMPTY on an interface-override graph) and refuses to claim success while any UserDefinedPin still carries the old name. The end-to-end oracle is still disk: save_asset -> reload_asset_package -> get_function_pins.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path owning the function graph.
function_name	string	yes	Name of the function graph (an interface's own function graph and an interface-override graph both work).
old_name	string	yes	Current parameter name, matched on the Entry node and on every Result node. A name present on only one of them is fine.
new_name	string	yes	New parameter name. Must be free on the terminal nodes; a collision is refused up front via the engine's own dry-run, before anything is touched.
write_redirect	boolean	no	Optional bool (default true). Also PERSIST the redirect as a +PropertyRedirects line in Config/DefaultEngine.ini, so it survives a restart and reaches the other machine. With false the redirect is registered in memory only and the rename EVAPORATES for anyone who opens the project later.
load_referencers	boolean	no	Optional bool (default true). Load the Blueprints the Asset Registry lists as referencers BEFORE renaming, so their nodes reconstruct in this session instead of the next one.

Returns: { blueprint_name, function_name, old_name, new_name, renamed: bool, terminals_renamed: [string], entry_pins_after: [string], result_pins_after: [string], entry_user_pins_after: [string], result_user_pins_after: [string], redirect_registered: string, redirect_persisted_to: string|null, referencers_loaded: [string], must_compile_and_save: [string], warning: string } -- the *_user_pins_after pair is the SERIALIZED side (UserDefinedPins): empty on an interface-override graph is normal, but the old name appearing there is the rename that will revert on restart.

reparent_blueprint

Destructive.

Change a Blueprint's parent class and recompile with the editor's own reparent compile flags (delta serialization + skip-new-variable-defaults, whose absence crashes the reinstancer on Blueprints holding class-typed variables). NO snapshot and NO rollback here -- reparent_blueprint_safe adds those, and even its rollback is only PARTIAL (it restores the parent but leaves SCS components RENAMED), so after ANY failed attempt restore the .uasset with git checkout BEFORE measuring again or the leftovers read as pre-existing damage. Errors when the parent is already that class.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
new_parent_class	string	yes	New parent class: /Script/Module.Class, a Blueprint's generated class path (/Game/Dir/BP_X.BP_X_C), or a resolvable class name

Returns: { blueprint_name, old_parent, new_parent, reparented } -- reparented is set unconditionally on the success path; the real oracles are get_blueprint_parent, the component overrides (apply_component_property_overrides re-authors them) and git status of the .uasset.

reparent_blueprint_safe

Destructive.

Guarded, rollback-capable Blueprint reparent -- PREFER THIS OVER the raw reparent_blueprint, which has none of these guards. It adds: a pre-flight snapshot (parent chain, own-variable count, CDO component count); an OPTIONAL variable de-collision rename (rename_colliding_vars) for own variables whose name collides with a member the NEW parent already declares, which a plain reparent would otherwise clobber; the delta-serialization compile flags, without which a Blueprint with more than ~10 type-pinned variables CRASHES the editor during reinstancing; the same SCS-root reconciliation the Blueprint editor itself does, so a silently renamed component ("Mesh" -> "Mesh1") is reported instead of hidden; an invariant post-check (parent matches, no compile error, own-variable count did not shrink); and, on failure, an in-memory auto_rollback that restores the original parent, restores the component names and recompiles. It never saves to disk. This is a genuinely destructive multi-step transaction: run it with dry_run=true first on any real fork -- that reports the plan and the would-rename set without mutating anything.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path to reparent.
new_parent_class	string	yes	New parent class name or path (native /Script, /Game/.../BP.BP_C, or a BP asset path -> its GeneratedClass).
dry_run	boolean	no	Optional (default false): analyze + report the plan (snapshot, would-rename vars, component collisions) without mutating.
rename_colliding_vars	boolean	no	Optional (default false): before reparenting, rename own NewVariables that collide by name with a member on the new parent.
auto_rollback	boolean	no	Optional (default true): on post-check failure, restore the original parent, restore the SCS node names and recompile.
reconcile_scene_root	boolean	no	Optional (default true): run the editor's own post-reparent conform pass -- ValidateSceneRootNodes + PrepareToConformSparseClassData + a second pass after the compile. Setting it FALSE disables all three; it exists only as a bisect escape hatch.
treat_component_renames_as_regression	boolean	no	Optional (default false): count a silently renamed SCS component as a post-check regression (which triggers auto_rollback).

Returns: { blueprint_name, blueprint_path, old_parent, new_parent, dry_run, reparented, renamed_variables:[{from,to}], pre_variable_count, post_variable_count, pre_component_count, post_component_count, pre_scs_node_count, post_scs_node_count, scene_root_reconciled, scene_root_reconciled_post_compile, default_scene_root_removed, sparse_class_data_conform_prepared, compile_messages:[{severity,text}], compile_error_count, compile_warning_count, renamed_components:[{guid,from,to,matched_by}], removed_components:[{guid,name}], components_without_guid, colliding_components:[{name,own_class,parent_class}], child_only_components:[{name,class}], compile_status, parent_match, compile_ok, variables_intact, components_intact, post_check_ok, rolled_back, rollback_complete, rollback_restored_components:[{guid,name}] (snapshotted nodes whose name MATCHES again after the rollback), rollback_unrestored_components:[{guid,expected_name,actual_name}], rollback_compile_messages:[{severity,text}], regressions:[string], saved_to_disk (always false -- this tool never saves), persistence_note, verification, verification_checks, success }

run_asset_action_utility

Destructive.

Run (or introspect) a scripted action on an Asset/Actor Action Utility

Parameter	Type	Required	Description
utility_path	string	yes	Object path of the utility blueprint, e.g.
function_name	string	no	CallInEditor action to run (default first action)

Returns: { utility_path, kind, generated_class, action_functions, function_name, function_found, invoked, note }

run_editor_utility_widget

Destructive.

Spawn and register an Editor Utility Widget Blueprint as an editor tab

Parameter	Type	Required	Description
widget_blueprint_path	string	yes	/Game path of the Editor Utility Widget Blueprint

Returns: { widget_blueprint_path, asset_path, tab_id, registration_name, registered, tab_exists, widget_spawned }

set_blueprint_component_array_element

Destructive, idempotent.

Author ONE element of a TArray property on a Blueprint component TEMPLATE (own SCS, or ICH-aware for a component inherited from an ancestor Blueprint): patch named struct members of an existing element, insert a new element at an index, or remove one. Every OTHER element is exported before and after and compared, so a whole-array rewrite that quietly loses the empty/None gaps cannot pass itself off as a targeted edit. There is deliberately NO 'move' operation.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset path or short name
component_name	string	yes	Component variable name (own or inherited)
property_name	string	yes	Name of the TArray property on the component template
index	number	yes	0-based element index. set_fields/remove need an existing index; insert accepts 0..Num (Num appends)
operation	string	no	'set_fields' (default), 'insert' or 'remove'
fields	object	no	Object of { StructMemberName: value } applied to the element. Used by set_fields, and by insert when the element type is a struct
element	any	no	Whole-element JSON value. Used by insert for NON-struct element types (or instead of 'fields' for a struct)
compile	boolean	no	Optional bool (default true): compile so the edited template reinstances
save	boolean	no	Optional bool (default true): save the Blueprint package after the compile

Returns: { success, error?, data: { blueprint_name, component_name, property_name, source, operation, index, inner_type, num_before, num_after, fields_applied[], field_errors[], siblings_unchanged, siblings_changed[], element_value, post_compile_num, post_compile_element, compiled, saved, save_error?, verification } }

set_blueprint_component_collision

Destructive, idempotent.

Set collision on a Blueprint component TEMPLATE (own SCS or inherited via ICH), not on a spawned actor, applying in this order: profile through SetCollisionProfileName (which expands the profile into the FBodyInstance response array -- a raw reflection write would set the string and leave BodyInstance inconsistent, and that is the whole reason this is a separate tool), then collision_enabled, then per-channel responses. Use it instead of set_blueprint_component_property for anything collision-shaped. Unknown channel, response or collision_enabled names are hard errors, never a silent default. Note the ORDER: a later profile would reset the per-channel responses, so responses always win here.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset path or name (required)
component_name	string	yes	Component to modify (required); must resolve to a UPrimitiveComponent or the call errors with "no collision to set"
profile	string	no	Collision profile name, e.g. "BlockAll" (optional). Applied FIRST, so it does not undo the per-channel responses below.
collision_enabled	string	no	ECollisionEnabled value name: NoCollision, QueryOnly, PhysicsOnly or QueryAndPhysics (optional). Any other string is an error.
responses	object	no	Object mapping channel -> response, e.g. {"Visibility":"Ignore","ECC_Pawn":"Overlap"} (optional). Channels accept the friendly display name or an ECC_* token (custom project channels included); responses are Ignore, Overlap or Block. An unknown channel is refused rather than defaulting to WorldStatic.
compile	boolean	no	Optional bool (default FALSE): compile the Blueprint afterwards so the FBodyInstance change reinstances on the next spawn/PIE. Without it the edit stays in the uncompiled template.
return_messages	boolean	no	No effect here: it is only read by the compile this tool may run internally, whose message log is discarded. Call compile_blueprint directly if you want the messages.

Returns: { success, data: { blueprint_name, component_name, source ("scs" | "inherited-ich" | "inherited-native": which template was written), profile?, collision_enabled?, responses_applied: [{channel, response}], compiled } } -- responses_applied lists ONLY the per-channel writes; profile and collision_enabled appear as their own fields only when they were given. Nothing is re-read: verify with get_blueprint_component_property or get_collision_info.

set_blueprint_component_property

Destructive, idempotent.

Set the DEFAULT of a property on a Blueprint component TEMPLATE, including components INHERITED from an ancestor Blueprint (routed through this class' InheritableComponentHandler) or native inherited subobjects; only FRESH instances read the new value. THREE TRAPS, all with the same shape (a green return over a different reality): (1) it can drop an entire OTHER component from the Blueprint IN MEMORY while disk and git stay clean -- count get_blueprint_components before and after, and reload_asset_package(on_dirty="discard") is the cure; (2) on an OBJECT-REFERENCE property it can write None and report override_persisted:true, wiping the inherited default -- check with get_blueprint_component_overrides; (3) actors ALREADY PLACED in a level keep their serialized value, so only runtime-spawned ones change. Read the effective value with get_blueprint_component_property (the read-only twin, which never mints an override), and use apply_component_property_overrides for several writes at once.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset path or short name
component_name	string	yes	Component variable name (own or inherited)
property_name	string	yes	Property to set on the component template
property_value	any	no	New value (any JSON type; same importer as set_component_property). An array value REWRITES THE WHOLE ARRAY, including the empty/None gaps -- set_blueprint_component_array_element edits one element and proves the siblings did not move.

Returns: { blueprint_name, component_name, property_name, component_class, source, override_persisted } -- source tells you which template was hit (scs / inherited-ich / inherited-scs / inherited-native) and override_persisted only guards the ICH case; NEITHER field re-reads the value, so they are not proof the write landed.

set_blueprint_function_pure

Destructive, idempotent.

Mark a Blueprint function as PURE (or back to impure), the editor's "Pure" checkbox: a pure function has no exec pins and is re-evaluated wherever its output is read. REQUIRED to finish a UMG property binding -- FDelegateEditorBinding::IsBindingValid refuses any function that is not FUNC_BlueprintPure or const, so add_widget_property_binding will report valid:false until this has been run on the function. The counterpart reader is get_blueprint_functions_list's is_pure, which reads the same flag off the same UK2Node_FunctionEntry. WARNING: Turning a function pure REMOVES its exec pins: any existing wire into or out of them is dropped by the reconstruct, so do this BEFORE building the function's body, not after.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint owning the function.
function_name	string	yes	Name of the function GRAPH (not an event; events cannot be pure).
is_pure	boolean	no	true to mark pure (default true), false to make it impure again.

Returns: { blueprint_name, function_name, is_pure, was_pure, changed, function_flags } -- is_pure is RE-READ from the entry node after the compile, so it is evidence and not an echo.

set_bp_class_replication

Destructive, idempotent.

Set class-level ACTOR replication on a Blueprint's CDO (bReplicates, optionally bAlwaysRelevant), compile, and read the values back off the RE-FETCHED post-compile CDO. Actor Blueprints only: a component Blueprint is refused (component replication is set_component_replication). Related reader trap: audit_replication's class_replicates reads the ACTOR flag, so it reports false for every component Blueprint whatever its CDO says.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of an Actor Blueprint (must be compiled at least once).
replicates	boolean	yes	Whether the Actor class replicates to network clients. Required.
always_relevant	boolean	no	Sets the Actor's bAlwaysRelevant flag; only applied when the field is present

Returns: { blueprint_name, replicates, always_relevant_set, always_relevant } -- values re-read from the CDO after compiling; always_relevant is only present when it was requested.

set_bp_function_rpc

Destructive, idempotent.

Turn a Blueprint FUNCTION into an RPC (rpc_type Server / Client / NetMulticast, or NotReplicated to undo it, plus reliable), then compile and read the FUNC_Net* flags back off the entry node. This is the ONLY headless way to author an RPC THAT TAKES ARGUMENTS: add_function_parameter cannot reach a custom event, so build the RPC as add_blueprint_function -> compile_blueprint -> add_function_parameter -> here. Engine limits that follow: a replicated function cannot return a value and cannot host latent nodes (put a Delay in a separate, parameterless custom event).

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
function_name	string	yes	Name of an existing FUNCTION graph on the Blueprint (a custom event has no entry node here and is refused).
rpc_type	string	yes	One of "NotReplicated", "Server", "Client", "NetMulticast" (case-insensitive).
reliable	boolean	no	Mark the RPC reliable; ignored (and cleared) when rpc_type is NotReplicated; defaults to false

Returns: { blueprint_name, function_name, rpc_type, is_net, reliable, function_flags } -- re-read from the entry node's flags after compiling; rpc_type is the RESOLVED type, so compare it with what you asked for. Proof that the call really crosses the wire is not here: drive it in PIE and read the resulting state on the OTHER side.

set_bp_variable_default

Destructive, idempotent.

Set the default value of a variable DECLARED on this Blueprint: writes the live CDO and mirrors the result back into the serialized variable description so it survives save/reload. LIMIT (not a lie, a hard boundary): it CANNOT touch an INHERITED variable -- it answers "Variable 'X' is not declared on this blueprint" -- so the "child that only overrides a parent default" pattern needs the CDO route (execute_python + set_editor_property + compile_blueprint + save). And on a class with actors already placed in a level, the placed instances keep their serialized value: verify on the instances, never on the CDO.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
variable_name	string	yes	Name of a variable declared on THIS Blueprint (inherited ones are refused)
value	string	no	New default in exported-text form, parsed into the variable's type; empty allowed. A value the type cannot parse is an error AND the previous value is restored (the engine's struct import zeroes the target before parsing, so a failed parse wipes the CDO).

Returns: { blueprint_name, variable_name, default_value, roundtrip_verified } -- default_value is re-exported from the CDO after the write, so it is the real stored value. WARNING: roundtrip_verified:false means the exported text does NOT re-import into the type (e.g. FGameplayTagContainer): the CDO holds the right value and the compiler's property copy carries it, but the serialized description was deliberately left empty because feeding an unparseable string back through a Full compile ZEROES the default. Verify that variable on the CDO after compiling, and prefer wiring it in the graph if it must survive a fresh regeneration.

set_bp_variable_metadata

Destructive, idempotent.

Set the editor-facing checkboxes and text of an existing Blueprint variable: instance_editable (per-instance editability), save_game (CPF_SaveGame -- whether the variable goes into a .sav), expose_on_spawn (adds the variable as a pin on SpawnActor), category and tooltip. Only the fields present are touched; passing none is an error. This is the fix for a variable created by add_blueprint_variable, which is born NOT instance-editable while the readers report it as editable. Variable must be declared on THIS Blueprint; on a library variable the answer is a child class of your own, not this call. WARNING: this call does NOT compile: it structurally-modifies the Blueprint, which regenerates the SKELETON only, so a save_game just written is authored but NOT yet on the generated class the save archive reads -- the response says so in save_game_needs_compile, and the loop that finishes the job is compile_blueprint -> save_asset -> get_blueprint_variable_detailed_info and check save_game_generated.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
variable_name	string	yes	Name of a variable declared on THIS Blueprint (inherited ones are refused).
instance_editable	boolean	no	true = editable on each placed actor. Verify by WRITING the placed instance and reading it back; the reporting field is unreliable for every variable.
save_game	boolean	no	true = tick "SaveGame" (CPF_SaveGame), so a SaveGame archive (ArIsSaveGame) serializes this variable; false unticks it. The only headless way to set this flag -- set_property_value, Python, set_bp_variable_replication and BlueprintEditorLibrary all refuse it. Needs a compile to reach the generated class.
expose_on_spawn	boolean	no	true = the variable shows up as an input pin on SpawnActorFromClass. Verify on the NODE's pins, not on get_blueprint_variables' expose_on_spawn, which reports false for variables that ARE exposed.
category	string	no	Category to group the variable under in the editor
tooltip	string	no	Tooltip text shown for the variable

Returns: { blueprint_name, variable_name, updated, save_game?, save_game_generated?, save_game_needs_compile? } -- updated:true only means at least one field was applied, not that it persisted. The three save_game_* fields appear only when save_game was passed, and are READ BACK after the write: save_game off the variable descriptor, save_game_generated off the FProperty of the generated class.

set_bp_variable_replication

Destructive, idempotent.

Set a Blueprint variable's replication mode -- None / Replicated / RepNotify (RepNotify also creates the OnRep_<Variable> function graph if missing) -- then compiles and reads CPF_Net/CPF_RepNotify back. TRAP: the full green report can come back WITHOUT the flag surviving into the generated class (a variable reported is_replicated:true that never replicates; re-running this same call fixes it). The ground truth is audit_replication (its payload's replicated_variables list), then compile and re-audit -- never this return, and never one client alone.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
variable_name	string	yes	Name of a variable DECLARED on this Blueprint (inherited/native variables are refused).
mode	string	yes	One of "None", "Replicated", "RepNotify" (case-insensitive). "None" also clears the RepNotify function and resets the lifetime condition.

Returns: { blueprint_name, variable_name, mode, is_replicated, is_rep_notify, rep_notify_func, property_flags } -- read back from the variable's flags after compiling, which is necessary but NOT sufficient (see the trap above).

set_component_replication

Destructive, idempotent.

Set bReplicates on ONE SCS component TEMPLATE of a Blueprint (the archetype, not a spawned actor's instance), compile, and read it back off the template. It governs the component's own PROPERTY replication; note that a component declared in the SCS already routes its RPCs through its stable network name WITHOUT this flag (a component added at RUNTIME does not, and loses them). For the owning actor use set_bp_class_replication.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name (or full object path) of the Blueprint.
component_name	string	yes	SCS component variable name on this Blueprint (inherited-only components have no local SCS node and are not found).
replicates	boolean	yes	Whether the component should replicate. Required.

Returns: { blueprint_name, component_name, replicates } -- replicates is re-read from the template after compiling.

set_event_dispatcher_signature

Destructive, idempotent.

Add to (mode="add", the idempotent default) or rewrite (mode="replace") the parameter list of a dispatcher this Blueprint OWNS -- inherited dispatchers have no local signature graph and are refused with the list of owned ones. Every requested type is resolved BEFORE anything is mutated, so a bad type aborts cleanly. The parameters become the OUTPUT pins of every bound handler and the INPUT pins of add_broadcast_node; existing nodes keep stale pins until compile_blueprint reconstructs them.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path that OWNS the dispatcher (inherited dispatchers cannot be edited here).
dispatcher_name	string	yes	Name of an existing event dispatcher (created by add_event_dispatcher or the editor).
params	array	yes	Array of parameter specs to add: [ { name: string, type: string } ]. Dispatcher params are input-only; 'type' accepts the same strings as add_function_parameter (bool, int, int64, float, string, name, text, byte, Vector, Array<T>, an object/class/struct/enum name or path).
mode	string	no	"add" (default, idempotent: skip a param whose name already exists) or "replace" (clear the existing signature first, then add the given params).

Returns: { blueprint_name, dispatcher_name, mode, added: [string], params: [ { name, type } ], param_count }

set_mesh_material_color

Destructive, idempotent.

Tint one material slot of a Blueprint component template by creating a DYNAMIC material instance (MID) over the current or given material, setting one vector parameter, and assigning the MID to the slot. A MID is a RUNTIME object, so this is a quick preview, NOT the way to author a change that must survive save/reload -- for a persistent tint make a MaterialInstanceConstant and assign it with apply_material_to_blueprint. A parameter_name the material does not declare is accepted silently and simply does nothing.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of an OWN SCS component; must be a UPrimitiveComponent
color	array	yes	RGBA color [R, G, B, A] as floats, each clamped to 0.0-1.0; exactly 4 values are required
material_slot	number	no	Optional slot index; defaults to 0
parameter_name	string	no	Optional vector parameter name; defaults to "BaseColor". A name the material does not declare is NOT reported as an error -- it just has no visible effect.
material_path	string	no	Optional material asset path to use as the MID's parent; without it the component's current slot material is used, falling back to /Engine/BasicShapes/BasicShapeMaterial

Returns: { component: string, material_slot: int, parameter_name: string, color: [number, number, number, number], success: bool } -- success:true only means the MID was created and assigned; re-read with get_blueprint_material_info after a save/reload to see whether anything persisted.

set_physics_properties

Destructive, idempotent.

Set simulate-physics, mass override, linear and angular damping on ONE primitive component TEMPLATE of a Blueprint (an OWN SCS node only -- inherited components are not found here, and it is the template, not a placed actor). Only the fields present are touched. It does NOT compile and does NOT save. For any other property of a component template use set_blueprint_component_property, which is ICH-aware and reaches inherited components.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of an OWN SCS component; must resolve to a UPrimitiveComponent or the call errors
simulate_physics	boolean	no	Optional bool to toggle physics simulation
mass	number	no	Optional mass override in kg (applied as SetMassOverrideInKg, not a scale)
linear_damping	number	no	Optional linear damping coefficient
angular_damping	number	no	Optional angular damping coefficient

Returns: { component: string } -- just the component name back. NOTHING is read back, so verify with get_blueprint_component_property on each property you set.

set_pin_default_value

Destructive, idempotent.

Write the literal default of an UNCONNECTED input pin and return the value read BACK off the pin. Struct pins are canonicalized: a bare GameplayTag name becomes (TagName="X") and an UNREGISTERED tag is rejected up front instead of silently landing as an empty tag; value_json nativizes any struct (and is the only way to put SEVERAL tags in a GameplayTagContainer). Array/set/map pins are refused (use a MakeArray/MakeSet/MakeMap node) and so are pins currently split into sub-pins (recombine_blueprint_pin first). A plain string is fine for an FText pin. TRAP: on a FormatText "Format" pin the literal IS written but the {argument} pins are NOT created, leaving a valid, useless node -- build the string with Concat_StrStr / Conv_StringToText instead.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint asset name or path
node_id	string	yes	NodeGuid of the node owning the pin
pin_name	string	yes	Pin name; an INPUT pin of that name is preferred, any pin with the name is the fallback
value	string	no	Literal default in the pin's exported-text form; empty string allowed (clears it). For a struct pin, "()" clears and a leading "(" is passed through untouched.
value_json	object	no	Optional JSON object nativized into the struct's export-text form, for STRUCT pins only. For an FGameplayTagContainer it must carry a "GameplayTags" array (["A","B"] or [{"TagName":"A"}]) and every tag is validated; takes precedence over 'value'.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { node_id, pin_name, default_value } -- default_value is re-read from the pin AFTER the write, so it is the oracle for what actually landed (a rejected value shows up as the old one).

set_property_access_path

Destructive, idempotent.

Rewrite a UK2Node_PropertyAccess node's binding Path and reconstruct the node so the leaf property re-resolves and the Value pin re-types, then return the path READ BACK -- so resolved:true is real evidence the new binding points at something. It does NOT recompile: follow with compile_blueprint + get_compile_errors. reconstructed:false means the PropertyAccessEditor feature was unavailable: the path WAS written but text_path/resolved_pin stay stale until the graph reopens.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path (usually an Animation Blueprint).
node_id	string	yes	NodeGuid of the property-access node; any other node class is refused by name.
path	any	no	The new path: either an array of segment strings (["InAnimInstance","Foo"]) OR a dotted string ("InAnimInstance.Foo"). An empty result is an error, never a cleared binding.
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted.

Returns: { node_id, graph_name, reconstructed, path:[string], text_path, resolved, resolved_pin, note? } -- path/text_path/resolved are re-read AFTER the reconstruct, so they are the oracle rather than an echo.

set_replication_condition

Destructive, idempotent.

Set the ELifetimeCondition (COND_OwnerOnly, COND_SkipOwner, COND_InitialOnly...) that decides WHICH clients get a replicated variable, then compile. It is the second half of set_bp_variable_replication, which decides WHETHER it replicates at all: on a variable that is not Replicated/RepNotify the condition is stored and completely INERT, and the response says so through is_replicated:false plus a "note". Blueprint-declared variables only.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
variable_name	string	yes	Name of a variable DECLARED on this Blueprint (inherited ones are refused).
condition	string	yes	ELifetimeCondition name, with or without the COND_ prefix (e.g. "OwnerOnly" or "COND_OwnerOnly"); an unknown name is an error.

Returns: { blueprint_name, variable_name, condition, is_replicated, note? } -- condition is the canonical COND_ name that was stored; is_replicated:false means the setting has no effect yet.

set_static_mesh_properties

Destructive, idempotent.

Assign a static mesh asset and/or a slot-0 material to a mesh component TEMPLATE of a Blueprint (an OWN SCS node, not a placed actor), in one call. Does NOT compile and does NOT save. Use apply_material_to_blueprint when only a material is changing or the slot is not 0, and get_blueprint_material_info to read the resulting slots back.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
component_name	string	yes	Name of an OWN SCS mesh component
static_mesh	string	no	Optional asset path of the UStaticMesh to assign
material	string	no	Optional asset path of the UMaterialInterface for slot 0

Returns: { component: string } -- name only, no verification: read the result with get_blueprint_material_info / get_blueprint_component_property.

spawn_blueprint_actor

Additive.

Spawn an instance of a Blueprint class as an actor and report WHICH world took it and whether the actor has AUTHORITY. The default (world absent or 'editor') places it in the EDITOR level, not in play. For anything that must exist for every player during PIE use world='server'; world='pie' is ambiguous and can land on the CLIENT, where the actor has no authority, no AI controller and no server-side existence while looking identical in the payload. The actor is NOT saved into the map: save_level afterwards for an editor-world spawn.

Parameter	Type	Required	Description
blueprint_name	string	yes	Name of the blueprint
actor_name	string	yes	Label applied to the spawned actor (SetActorLabel); it is not the object name and is not made unique
location	array	no	Optional [x, y, z] world location
rotation	array	no	Optional [pitch, yaw, roll] world rotation
world	string	no	Optional world selector: absent/'editor' (default) spawns into the editor level | 'server' spawns into the PIE world WITH AUTHORITY (what you want for anything that must exist for every player: an actor spawned into the client world has no authority and no server-side existence) | 'client' | 'pie:N' | 'pie' (ambiguous: PlayWorld, else the first PIE context -- can land on the CLIENT) | 'game' (alias of 'pie')

Returns: { actor JSON via DescribeActorObject, world: string, has_authority: bool (AActor::HasAuthority() read off the spawned actor), local_role: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

split_blueprint_pin

Destructive.

Split a struct-typed pin (Vector, Rotator, Transform...) into its scalar sub-pins and return their names, so each component can be wired or defaulted on its own instead of writing the whole struct literal. Refused when the schema says the pin is not splittable. Note the interaction: set_pin_default_value REFUSES a pin that is currently split -- recombine_blueprint_pin first if you want to write the struct as one value.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
node_id	string	yes	NodeGuid of the node owning the pin.
pin_name	string	yes	Name of the struct pin to split (either direction).
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { split, sub_pins:[string] } -- sub_pins are the names to pass to connect_pins / set_pin_default_value from now on (e.g. "NewLocation_X").

validate_pin_connection

Read-only.

Dry-run the K2 schema's verdict on a pin pair WITHOUT touching the graph: returns valid plus the schema's own message (which names the incompatible types) and its raw response code. connect_pins runs the same check and then connects, so use this one to test a plan before committing a build_blueprint_graph batch whose rollback can be refused, or to find out WHY a connection was rejected without leaving anything behind.

Parameter	Type	Required	Description
blueprint_name	string	yes	Blueprint name or path.
source_node_id	string	yes	NodeGuid of the source node.
source_pin	string	yes	Output pin name on the source node (falls back to any pin with that name).
target_node_id	string	yes	NodeGuid of the target node; must be in the same graph as the source.
target_pin	string	yes	Input pin name on the target node (falls back to any pin with that name).
graph_name	string	no	Target graph name; defaults to the Blueprint's event graph when omitted

Returns: { valid, message, response_code } -- valid is false only for an outright DISALLOW; a response that would connect WITH a conversion node or by breaking an existing link still reports valid:true, and "message" is where that shows.