Execute arbitrary Python code inside the running Unreal Editor.

The unreal module is pre-imported. Set a variable named result to return structured data back to Claude Code.

Check if the UE5 editor bridge is running and responsive.

Search the Asset Registry by class, path, and/or name pattern.

Args: class_type: Shortcut ("material", "blueprint", "static_mesh", "texture", "data_table", "niagara_system", etc.) or "PackagePath.ClassName" path: Content path filter (e.g. "/Game/Materials") name_pattern: Substring match on asset name (case-insensitive) recursive: Search subdirectories (default True) max_results: Maximum results to return (default 200)

List assets in a Content Browser directory.

Args: path: Content path (e.g. "/Game", "/Game/Materials") class_filter: Optional class shortcut (e.g. "material", "blueprint")

Open an asset in the UE5 editor (blueprint, material, data table, widget, etc.).

Get asset metadata: class, package, and key properties.

Get all editable properties of an asset.

Set a property on an asset.

Args: property_name: Property name (e.g. "two_sided", "blend_mode") property_value: JSON-encoded value (e.g. "true", "0.5", '"translucent"')

Find assets that reference or are referenced by the given asset.

direction: "dependents" (who uses this), "dependencies" (what this uses), or "both"

Duplicate an asset to a new location.

Rename or move an asset. UE5 automatically fixes all references.

Delete an asset or directory from the Content Browser.

Checks for references first unless force=True. Paths without a dot are treated as directories.

Save a specific asset to disk.

Save all unsaved (dirty) assets.

Import an external file (texture, mesh, FBX, etc.) into the Content Browser.

Args: source_file: Absolute path to file on disk (e.g. "C:/textures/wood.png") destination_path: Content Browser path (e.g. "/Game/Textures") destination_name: Custom asset name (default: source filename without extension) replace_existing: Overwrite if asset already exists (default True)

Import multiple files into the Content Browser in one batch.

Provide EITHER 'files' (explicit list) OR 'source_directory' (scan a folder).

Args: destination_path: Content Browser destination (e.g. "/Game/Textures") files: List of absolute file paths to import source_directory: Absolute path to a folder — all matching files will be imported extensions: File extensions to include when scanning a directory (e.g. ["png", "jpg", "fbx"]). If omitted with source_directory, all files are imported. replace_existing: Overwrite existing assets (default True)

Get currently selected assets in the Content Browser.

Navigate the Content Browser to show a specific asset.

Create a new Material asset.

Returns error if the asset already exists (avoids editor overwrite popup). Pass force=true to delete and recreate.

Args: name: Material name (e.g. "M_MyMaterial") path: Content Browser path blend_mode: opaque | masked | translucent | additive | modulate | alpha_composite | alpha_holdout shading_model: default_lit | unlit | subsurface | clear_coat | subsurface_profile | two_sided_foliage | cloth | eye | thin_translucent two_sided: Render on both sides opacity_mask_clip_value: Clip value for masked blend mode (0.0-1.0) force: If true, delete existing asset and recreate (default false)

Create a Material Instance from a parent material.

Returns error if asset already exists. Pass force=true to delete and recreate.

Args: parent_path: Full path to parent (e.g. "/Game/Materials/M_Base") name: Instance name (e.g. "MI_Red") scalar_params: JSON dict of scalar overrides — {"Opacity": 0.5, "Metallic": 1.0} vector_params: JSON dict of vector overrides — {"BaseColor": [1.0, 0.0, 0.0, 1.0]} texture_params: JSON dict of texture overrides — {"Texture": "/Game/Textures/T_Wood"} force: If true, delete existing asset and recreate (default false)

Build a complete material node graph in one atomic operation.

Creates expression nodes and wires them together in a single call. By default clears existing expressions first (safe rebuild — all external references stay intact).

Args: material_path: Full path to existing material (e.g. "/Game/Materials/M_Portal") nodes: JSON array of node definitions. Each node has: - type: Short class name (e.g. "TextureCoordinate", "Custom", "ScalarParameter", "Constant3Vector", "TextureSample", "Multiply", "Add", "Panner", "Time", "VectorParameter", "LinearInterpolate", "ComponentMask") Auto-prefixed with "MaterialExpression" if needed. - pos_x, pos_y: Graph position (default -300, 0) - properties: Dict of editor properties to set. Common ones: - parameter_name: str — name shown in material instances - default_value: number or [r,g,b,a] - slider_min, slider_max: float — slider range - group: str — parameter group name - Values starting with "/" are loaded as assets - Lists of 3-4 become LinearColor, lists of 2 become Vector2D For Custom HLSL nodes (type="Custom"), also supports: - code: HLSL source code string - description: Node title in the graph - output_type: "float" | "float2" | "float3" | "float4" - inputs: List of input pin names (e.g. ["UV", "Speed"]) - outputs: List of {"name": str, "type": str} for additional outputs connections: JSON array of connections. Each connection has: - from_node: Source node index (int, 0-based into nodes array) - from_pin: Output pin name ("" for default output) - to_node: Target node index (int) or "material" for material output - to_pin: Input pin name, or material property when to_node="material": BaseColor, Metallic, Specular, Roughness, Anisotropy, EmissiveColor, Opacity, OpacityMask, Normal, Tangent, WorldPositionOffset, Displacement, SubsurfaceColor, CustomData0, CustomData1, AmbientOcclusion, Refraction, PixelDepthOffset, ShadingModel, SurfaceThickness, FrontMaterial (FrontMaterial is for Substrate BSDF nodes — use get_available_material_pins to see which pins are active for a specific material) clear_existing: Remove existing expressions before building (default True)

Inspect a material's properties.

Always returns: blend mode, shading model, two-sided, expression count.

Use include (comma-separated) to request additional sections:

• "parameters": scalar/vector/texture parameter names

• "textures": used texture paths

• "statistics": shader instruction counts

Omit include to get only basic properties (minimal tokens). Pass include="parameters,textures,statistics" for everything.

Force recompile and save a material. Reports success/failure.

Get shader compilation errors for a material.

Returns error messages and the node indices that caused them. Recompiles first by default to get fresh errors.

Bulk-set material-level properties in one call.

Args: blend_mode: opaque | masked | translucent | additive | modulate | alpha_composite | alpha_holdout shading_model: default_lit | unlit | subsurface | clear_coat | etc. recompile: Recompile after setting properties (default True)

Read expression nodes in a material graph.

Use verbosity to control response size:

• "summary": index, type, position only (~30 tokens/node)

• "connections": + input connections (default, good balance)

• "full": + properties + available pins (large response)

Use type_filter to only return nodes matching a type substring (e.g. "Parameter" returns only parameter nodes).

Add a single expression node without clearing other nodes.

Returns the new node_index. Wire it up with connect_material_expressions.

node is a JSON object: {"type": "ScalarParameter", "pos_x": -1200, "pos_y": -400, "properties": {"parameter_name": "Speed", "default_value": 0.5}}

For Custom HLSL nodes, include top-level "code", "description", "output_type", "inputs", and "outputs" fields.

Connect two expression nodes using their indices.

Args: from_node: Source node index to_node: Target node index (e.g. "5") or "material" for material output to_pin: Input pin name, or material property when to_node="material": BaseColor, Metallic, Specular, Roughness, Anisotropy, EmissiveColor, Opacity, OpacityMask, Normal, Tangent, WorldPositionOffset, Displacement, SubsurfaceColor, CustomData0, CustomData1, AmbientOcclusion, Refraction, PixelDepthOffset, ShadingModel, SurfaceThickness, FrontMaterial from_pin: Output pin name ("" = primary output)

Delete a single expression node by index. Recompiles and saves automatically.

Remaining node indices may shift — re-query with get_material_graph_nodes afterwards.

Add comment boxes to a material graph for organization.

comments is a JSON array. Each entry: {text, pos_x, pos_y, size_x, size_y, font_size, color: [r,g,b], show_bubble, color_bubble, group_mode}.

Get detailed info for a single node, including all available input/output pins.

Use this before connecting nodes to discover exact pin names.

Query which expression node feeds each material output slot.

Only lists slots that have something connected.

Set a property on an existing material expression node.

Accepts snake_case ("parameter_name") or PascalCase ("ParameterName").

Common properties: parameter_name, default_value, slider_min, slider_max, group, texture, code, description, output_type, inputs, add_inputs, outputs, SpeedX, SpeedY, CoordinateIndex, R, Constant.

Move a material expression node to a new graph position.

Duplicate a node (same type and properties, offset from original).

Returns the new node_index. Connections are NOT copied.

Auto-layout all nodes using Unreal's built-in arrangement algorithm.

Get all overridable parameters from a Material Instance (scalar, vector, texture, switch).

Set a parameter override on a Material Instance.

Args: param_type: scalar | vector | texture | static_switch value: JSON-encoded — float, [r,g,b,a], "/Game/path", or true/false

List available material expression node types.

Use filter to narrow results (e.g. "texture", "parameter", "math", "noise"). Set max_results to limit output (0 = unlimited). Set include_details=false for compact output (type names only).

Look up pin names and editable properties for a node type WITHOUT creating one.

Returns input pins, output pins, and all editable properties with types and defaults. Use this BEFORE creating nodes to know exact pin names and avoid connection errors.

Special node types:

• Custom: Returns additional custom_hlsl_schema with code/inputs/outputs documentation.

• MaterialFunctionCall: Pass function_path to see the actual inputs/outputs of that function. Without it, pins will be empty since they depend on which function is loaded. Use search_material_functions to find functions first.

• Substrate nodes (SubstrateSlabBSDF, SubstrateShadingModels, etc.): Returns substrate_note explaining how to connect to FrontMaterial pin.

Args: type_name: Short type name (e.g. "Multiply", "TextureSample", "Custom", "MaterialFunctionCall", "SubstrateSlabBSDF", "SubstrateShadingModels") function_path: For MaterialFunctionCall only — path to the material function to load (e.g. "/Engine/Functions/Engine_MaterialFunctions03/Blends/Blend_Overlay"). Populates the node with the function's actual input/output pins.

Query all available material output pins for a specific material.

Returns every pin that is currently visible (based on material settings), whether it's connected, what type it expects, and which node feeds it.

Use this to discover valid to_pin values for connect_material_expressions with to_node="material". The available pins change based on blend mode, shading model, and whether Substrate is enabled.

Also reports substrate_enabled and has_front_material_connected status.

Disconnect a specific input pin on a material expression node.

Args: node_index: The target node whose input pin will be disconnected input_pin: Name of the input pin to disconnect

Search for Material Functions by name.

Args: filter: Name substring to match (e.g. "Blend", "Normal", "Fresnel") path: Content Browser path to search in (default "/Game") max_results: Maximum results to return (default 50) include_engine: Include engine built-in material functions

Diagnose connection issues in a material graph.

Categorises every node into:

• orphaned: no inputs AND output not consumed — safe to delete

• dead_ends: has inputs but output goes nowhere

• missing_inputs: some input pins are empty

• unconnected_inputs: ALL input pins are empty (node expects connections)

• unconnected_outputs: output not consumed by anything

Returns healthy=true when no orphaned or dead-end nodes exist.

Trace connections upstream and/or downstream from a specific node.

Shows exactly what feeds into each input pin and what consumes each output pin, including connections to material outputs (BaseColor, Normal, etc.).

Args: node_index: The node to trace from direction: "upstream" (what feeds in), "downstream" (what consumes output), or "both" (default) max_depth: How many hops to trace recursively (1 = immediate neighbors, 2+ = follow the chain). Max 50. Default 1.

Delete orphaned and/or dead-end nodes from a material graph.

WARNING: NEVER call this tool unless the user explicitly asks to clean up or delete unconnected nodes. Users may intentionally keep disconnected nodes as references, scratchpads, or work-in-progress. Deleting them without permission will cause data loss and frustration.

Args: mode: What to delete: "orphaned" — only nodes with NO connections at all (safest) "dead_ends" — nodes whose output goes nowhere (has inputs but no consumers) "all" — both orphaned and dead-ends dry_run: If true, reports what WOULD be deleted without actually deleting. Always use dry_run=true first to preview before deleting.

Create a new Material Function asset.

Returns error if asset already exists. Pass force=true to delete and recreate.

Args: name: Function name (e.g. "MF_CustomBlend") path: Content Browser path description: Function description shown in tooltips expose_to_library: Whether the function appears in the material editor's function library force: If true, delete existing asset and recreate (default false)

Inspect a Material Function: inputs, outputs, internal nodes.

Returns all FunctionInput pins (name, type, default value, sort priority), all FunctionOutput pins (name, connections), and a summary of internal nodes.

Build the internal node graph of a Material Function in one atomic call.

Same interface as build_material_graph but for Material Functions.

FunctionInput nodes use type="FunctionInput" with extra fields: input_name, input_type (Scalar/Vector2/Vector3/Vector4/Texture2D/TextureCube/ Texture2DArray/VolumeTexture/StaticBool/MaterialAttributes/TextureExternal/Bool/Substrate), description, sort_priority, use_preview_as_default, preview_value ([x,y,z,w])

FunctionOutput nodes use type="FunctionOutput" with extra fields: output_name, description, sort_priority

Connections between nodes use the same format as build_material_graph: from_node (int), from_pin (str), to_node (int), to_pin (str)

To connect a node to a FunctionOutput's input, use to_pin="" (the output has a single unnamed input pin labeled "A" internally).

Args: function_path: Full path to existing material function nodes: JSON array of node definitions connections: JSON array of connections clear_existing: Remove existing expressions before building (default True)

Add an input pin to a Material Function.

Args: function_path: Full path to existing material function input_name: Pin name (e.g. "BaseColor", "Strength", "UV") input_type: Scalar | Vector2 | Vector3 | Vector4 | Texture2D | TextureCube | Texture2DArray | VolumeTexture | StaticBool | MaterialAttributes | TextureExternal | Bool | Substrate description: Tooltip text sort_priority: Controls display order (lower = higher) use_preview_as_default: Use preview_value as the default when input is unconnected preview_value: JSON array for default value (e.g. "[0.5]", "[1.0, 0.0, 0.0, 1.0]") pos_x: Graph X position (default -600) pos_y: Graph Y position (default 0)

Add an output pin to a Material Function.

Args: function_path: Full path to existing material function output_name: Pin name (e.g. "Result", "Normal", "Mask") description: Tooltip text sort_priority: Controls display order (lower = higher) pos_x: Graph X position (default 200) pos_y: Graph Y position (default 0)

Modify an existing FunctionInput node's properties.

Args: function_path: Full path to existing material function node_index: Index of the FunctionInput node (from get_material_function_info) input_name: New pin name input_type: New type (Scalar/Vector2/Vector3/Vector4/Texture2D/TextureCube/ Texture2DArray/VolumeTexture/StaticBool/MaterialAttributes/ TextureExternal/Bool/Substrate) description: New tooltip sort_priority: New display order use_preview_as_default: Use preview value as default preview_value: JSON array for default value (e.g. "[0.5]", "[1.0, 0.0, 0.0, 1.0]")

Modify an existing FunctionOutput node's properties.

Args: function_path: Full path to existing material function node_index: Index of the FunctionOutput node (from get_material_function_info) output_name: New pin name description: New tooltip sort_priority: New display order

Diagnose issues in a Material Function's internal graph.

Reports:

• unconnected_outputs: FunctionOutput nodes with nothing wired to their input

• unused_inputs: FunctionInput nodes whose output nobody consumes

• orphaned: internal nodes with no connections at all

Returns healthy=true when no issues found.

Remove unconnected/orphaned nodes from a Material Function.

Deletes:

• FunctionOutput nodes with no input wired (duplicate output pins)

• FunctionInput nodes whose output nobody consumes (duplicate input pins)

• Orphaned internal nodes

WARNING: Only call when the user explicitly asks to clean up.

Args: dry_run: If true, reports what would be deleted without deleting.

Search for classes that can be used as Blueprint parents.

Use this BEFORE create_blueprint to find the correct parent class name. Returns a filtered list of matching classes — never dumps all classes.

Args: filter: Keyword to search for (e.g. "Miner", "Actor", "Pawn", "Widget") max_results: Maximum results (default 20, max 100) include_blueprint_classes: Also include Blueprint-generated classes (default True)

Create a new Blueprint asset from any C++ or Blueprint parent class.

Supports parent classes from ANY module (Engine, Game, plugins, etc.). Use search_parent_classes first to find the correct name.

parent_class accepts short names ("MinerActor"), prefixed ("AMinerActor"), full paths ("/Script/Jiggify.AMinerActor"), or BP paths ("/Game/Blueprints/BP_Base").

Add a component to a Blueprint's default components.

Args: blueprint_path: Full path to blueprint (e.g. "/Game/Blueprints/BP_MyActor") component_class: e.g. "StaticMeshComponent", "PointLightComponent" component_name: Optional custom name for the component

Get all default property values from a Blueprint's generated class CDO.

Unlike get_blueprint_variable_details (which only shows BP-defined variables), this reads the CDO and returns ALL editable properties — including C++ parent ones.

Args: filter: Substring to filter property names (case-insensitive) include_inherited: Include properties from C++ parent (default True)

Set default property values on a Blueprint's generated class CDO.

Works on ALL editable properties — C++ parent properties and BP-defined variables alike (e.g. SlotWidgetClass, MaxHealth, bCanFly).

Set a single property with property_name + property_value, or set multiple at once with a properties dict. Both can be used in the same call.

Args: blueprint_path: Full path to blueprint (e.g. "/Game/Blueprints/BP_MyActor") property_name: Name of a single property to set property_value: Value for the single property (JSON-compatible) properties: Dict of property names to values for batch setting

Spawn an actor in the level.

Args: name: Actor name actor_type: StaticMeshActor, PointLight, etc. location/rotation/scale: [x,y,z] arrays static_mesh: Path to static mesh asset (for mesh actors)

Get all currently selected actors in the editor viewport.

Get current editor level info (world name, actor count, actor list).

Get property values from a live actor instance placed in the world.

Unlike get_blueprint_class_defaults (CDO), this reads the placed instance — per-instance overrides are returned correctly.

Two output modes:

• Nested (default, flat=False): top-level FProperty names, structs as nested JSON. Filter only matches top-level names — best for quickly inspecting one actor.

• Flat (flat=True): every leaf returned as "Settings.BloomIntensity": value with a path-aware filter. Best for AI search ("find me everything containing 'bloom'").

Args: actor_label: Outliner label or UObject name. filter: Case-insensitive substring. Nested mode = top-level only; flat mode = matches full dotted path. include_components: Also return components' properties. flat: Return flat dotted-path dict instead of nested structure. max_depth: (flat mode) Max struct nesting depth. Default 3. include_metadata: (flat mode) Replace each value with full metadata object (type info, clamps, enum values, etc.). expand_arrays: (flat mode) Emit array elements as Field[N] entries. array_element_limit: (flat mode) Max elements emitted per array. Default 16.

Set a property at any nested path on a placed level actor instance.

Writes to the actual placed actor (not its CDO/Blueprint defaults), so editor overrides are preserved. Walks struct fields and array indices, fires PostEditChangeProperty on the top-level property, and marks the level dirty.

Args: actor_label: Actor's display label in the Outliner (or its UObject name). property_path: Dot-separated property path. Examples: "Settings.BloomIntensity" "Settings.ColorGradingHighlights.Gain" "Tags[0]" "Settings.bOverride_BloomIntensity" property_value: The value to write. Accepts: - Numbers, bools, strings for primitives and enums - JSON object for structs ({"R":1.0,"G":0.5,"B":0.0,"A":1.0} for FLinearColor) - UE text format string for structs ("(R=1.0,G=0.5,B=0.0,A=1.0)") - Asset path string for object/class references component_name: Optional. If set, the path is resolved starting from a component on the actor instead of the actor itself.

Returns: actor identification + the resolved top-level FProperty name.

Inspect type/clamp/enum metadata for properties on a placed actor.

Returns a flat dict keyed by dotted path with per-property metadata (cpp_type, ue_type, category, display_name, tooltip, current_value, clamp_min/max, ui_min/max, valid_values for enums, inner/element/key/value types for containers, object_class / meta_class for refs, plus is_struct/is_array/is_enum/is_object /is_bool / editable / transient / readonly flags).

ALSO returns a "_summary" header containing total_available, total_returned, truncated, next_cursor, own_count, inherited_count, class_chain, and a "categories" map (UPROPERTY Category -> count) — use this to navigate without flooding context. max_entries=0 returns ONLY the summary so you can plan first.

Args: actor_label: Outliner label or UObject name. property_path: Optional dotted path. Empty = enumerate top-level properties. If the path is a struct, enumerates that struct's fields. If a leaf scalar/enum, returns metadata for just that property. If an OBJECT REFERENCE, returns single-property metadata for the ref + a hint (use component_name to inspect the target's properties), unless descend_into_objects=True is passed. filter: Case-insensitive substring on full dotted path. category: Case-insensitive exact match against UPROPERTY(Category="X"). Sub-categories use "|" — e.g. "Lens|Bloom". depth: How many struct levels to expand below the start point. 0 = flat. expand_enums: Include valid_values list for enum-typed fields. include_inherited: Include properties from super classes. False = only those declared on the most-derived class (use to scope down components). descend_into_objects: When property_path lands on an FObjectProperty, enumerate the target object's class instead of returning a single metadata blob. Disabled by default — prefer component_name. max_entries: Hard cap on emitted entries. Default 50. 0 = summary only. Pair with cursor for pagination. cursor: Pagination offset. Use _summary.next_cursor from the previous response to fetch the next page. component_name: Optional. Anchor target object to a named component.

Spawn ANY AActor subclass by full path, short name, or Blueprint asset path.

Replaces the hardcoded whitelist of spawn_actor. Resolves class_path in this order:

1. Full UClass path with '.' (e.g. "/Script/Engine.PostProcessVolume", "/Script/Engine.SkyAtmosphere")

2. Blueprint asset path (e.g. "/Game/Blueprints/BP_Miner") — loads the asset and uses its GeneratedClass.

3. Short name fallback — iterates loaded UClasses for a name match (handles "PostProcessVolume", "APostProcessVolume", "Sky_Sphere_C", etc.)

Validates: must be AActor subclass, not abstract, not deprecated. Uses UEditorActorSubsystem::SpawnActorFromClass when available so Ctrl+Z restores.

Args: class_path: Full path, BP asset path, or short class name. name: Optional outliner label + UObject name. location: [x, y, z] world location. rotation: [pitch, yaw, roll] degrees. scale: [x, y, z] scale.

Flexible actor search across the level — combine any number of filters.

Use this to answer "is X in the world", "first 5 actors of class Y", "all actors starting with name Z and tagged W". All filters AND together. Returns total count scanned/matched even when results are truncated.

Args: name_pattern: Case-insensitive substring on UObject name (e.g. "Light"). label_pattern: Case-insensitive substring on outliner display label. class_filter: Class name (short or full path). When it resolves to a real UClass, uses IsA() (or exact_class for ==). Otherwise falls back to substring match on the actor's class name/path. tag: Match actors with this FName in their Tags. exact_class: When class_filter resolves to a UClass, require exact match instead of subclass. max_results: Cap on returned entries (0 = unlimited; truncated flag set). include_transform: Include location/rotation/scale per entry.

Get all rows and their field data from a Data Table asset.

Get a single row from a Data Table by its row name.

Get column names and types defined by the Data Table's row struct.

Add a new row, optionally setting initial field values.

data is a JSON string mapping field names to values, e.g. '{"FieldA": 1}'.

Update specific fields on an existing row (partial update).

Only fields present in data are modified; everything else keeps its value. data is a JSON string, e.g. '{"DisplayName": "Miner"}'.

Delete a row from a Data Table by name.

Rename a row in-place (preserves row order).

Copy an existing row under a new name.

Add a node to a Blueprint graph.

Node types by category: FLOW: Branch, Comparison, Switch, SwitchEnum, SwitchInteger, ExecutionSequence DATA: VariableGet, VariableSet, MakeArray CASTING: DynamicCast, ClassDynamicCast, CastByteToEnum UTILITY: Print, CallFunction, Select, SpawnActor SPECIAL: Timeline, GetDataTableRow, AddComponentByClass, Self, Knot EVENT: Event (specify event_type: BeginPlay, Tick, Destroyed, etc.)

Extra args are only needed for specific node types (message for Print, variable_name for Variable nodes, target_function for CallFunction, etc.).

Connect two nodes in a Blueprint graph.

Args: source_node_id: GUID of the source node source_pin_name: Output pin name on source target_node_id: GUID of the target node target_pin_name: Input pin name on target function_name: Function graph (empty = EventGraph)

Create a variable in a Blueprint.

variable_type: bool, int, float, string, vector, rotator

Modify properties of an existing Blueprint variable.

All parameters besides blueprint_name and variable_name are optional — only provided values are changed.

Add an event node (ReceiveBeginPlay, ReceiveTick, ReceiveDestroyed, etc.).

Delete a node from a Blueprint graph by GUID.

Set a node property or perform semantic editing.

Semantic actions (pass via 'action'): add_pin, remove_pin, set_enum_type, set_pin_type, set_value_type, set_cast_target, set_function_call, set_event_type

Each action has associated params (pin_type, pin_name, enum_type, new_type, target_type, target_function, target_class, event_type).

Create a new function in a Blueprint.

Add an input parameter to a Blueprint function.

Add an output parameter to a Blueprint function.

Delete a function from a Blueprint.

Rename a function in a Blueprint.

Read complete Blueprint content: event graph, functions, variables, components.

Analyze a specific graph — nodes, connections, and execution flow.

Get detailed info about Blueprint variables (empty name = all variables).

Get detailed info about Blueprint functions (empty name = all functions).

Compile a Blueprint.

List all actors in the current level.

Find actors whose name matches the given pattern.

Delete an actor from the level by name.

Set an actor's location, rotation, and/or scale.

Spawn a Blueprint actor instance in the level.

Set the static mesh on a StaticMeshComponent in a Blueprint.

Set physics properties on a Blueprint component.