@createlex/createlexgenai 1.0.0

package/python/ue_native_handler.py

@@ -0,0 +1,573 @@
+"""
+Native UE Python command handler.
+
+Translates JSON commands (same format as the CreatelexGenAI plugin's TCP protocol)
+into equivalent Python code using UE's built-in `unreal` module.
+This allows ALL 71 MCP tools to work WITHOUT the CreatelexGenAI plugin,
+using only UE's built-in Python Remote Execution or Web Remote Control.
+
+Each handler function takes a command dict and returns a result dict.
+"""
+
+import json
+
+
+def build_handler_script(command):
+    """
+    Given a command dict (with 'type' key), return a standalone Python script string
+    that can be executed inside UE's Python interpreter via Remote Execution.
+    The script prints a JSON result to stdout.
+    """
+    cmd_type = command.get("type", "")
+    builder = COMMAND_BUILDERS.get(cmd_type)
+    if not builder:
+        return _wrap_result(f'{{"success": false, "error": "Unknown command type: {cmd_type}. This tool requires the CreatelexGenAI plugin for full support."}}')
+    return builder(command)
+
+
+def _wrap_result(json_expr):
+    """Wrap a JSON expression in a print statement for capture."""
+    return f"import json, sys\ntry:\n    result = {json_expr}\n    print(json.dumps(result) if isinstance(result, dict) else result)\nexcept Exception as _e:\n    print(json.dumps({{'success': False, 'error': str(_e)}}))"
+
+
+def _wrap_script(script_lines):
+    """Wrap multi-line script with error handling and JSON output."""
+    indent = "    "
+    indented = "\n".join(indent + line for line in script_lines)
+    return f"""import json, sys, traceback
+try:
+{indented}
+except Exception as _e:
+    print(json.dumps({{"success": False, "error": str(_e), "traceback": traceback.format_exc()}}))
+"""
+
+
+# ── Command builders ────────────────────────────────────────────────────────
+
+def _build_handshake(cmd):
+    msg = json.dumps(cmd.get("message", ""))
+    return _wrap_script([
+        f'print(json.dumps({{"success": True, "message": "Handshake OK: " + {msg}}}))'
+    ])
+
+
+def _build_execute_python(cmd):
+    script = cmd.get("script", "")
+    # Execute the script directly, capture output
+    return _wrap_script([
+        'import io, contextlib',
+        '_buf = io.StringIO()',
+        'with contextlib.redirect_stdout(_buf):',
+        f'    exec({json.dumps(script)})',
+        '_output = _buf.getvalue()',
+        'print(json.dumps({"success": True, "output": _output}))'
+    ])
+
+
+def _build_execute_unreal_command(cmd):
+    command = cmd.get("command", "")
+    return _wrap_script([
+        'import unreal',
+        f'unreal.SystemLibrary.execute_console_command(None, {json.dumps(command)})',
+        f'print(json.dumps({{"success": True, "output": "Command executed: {command}"}}))'
+    ])
+
+
+def _build_spawn(cmd):
+    actor_class = json.dumps(cmd.get("actor_class", "Cube"))
+    loc = json.dumps(cmd.get("location", [0, 0, 0]))
+    rot = json.dumps(cmd.get("rotation", [0, 0, 0]))
+    scale = json.dumps(cmd.get("scale", [1, 1, 1]))
+    label = json.dumps(cmd.get("actor_label", ""))
+    return _wrap_script([
+        'import unreal',
+        f'actor_class_name = {actor_class}',
+        f'loc = {loc}',
+        f'rot = {rot}',
+        f'scale = {scale}',
+        f'label = {label}',
+        '# Map simple names to mesh paths',
+        'shape_map = {"Cube": "/Engine/BasicShapes/Cube.Cube", "Sphere": "/Engine/BasicShapes/Sphere.Sphere", "Cylinder": "/Engine/BasicShapes/Cylinder.Cylinder", "Cone": "/Engine/BasicShapes/Cone.Cone"}',
+        'if actor_class_name in shape_map:',
+        '    actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.StaticMeshActor, unreal.Vector(*loc), unreal.Rotator(*rot))',
+        '    if actor:',
+        '        mesh = unreal.EditorAssetLibrary.load_asset(shape_map[actor_class_name])',
+        '        actor.static_mesh_component.set_static_mesh(mesh)',
+        '        actor.set_actor_scale3d(unreal.Vector(*scale))',
+        '        if label: actor.set_actor_label(label)',
+        '        print(json.dumps({"success": True, "actor": actor.get_actor_label()}))',
+        '    else:',
+        '        print(json.dumps({"success": False, "error": "Failed to spawn actor"}))',
+        'else:',
+        '    # Try as a class path',
+        '    try:',
+        '        cls = unreal.load_class(None, f"/Script/Engine.{actor_class_name}") if "." not in actor_class_name else unreal.load_class(None, actor_class_name)',
+        '        actor = unreal.EditorLevelLibrary.spawn_actor_from_class(cls, unreal.Vector(*loc), unreal.Rotator(*rot))',
+        '        if actor:',
+        '            actor.set_actor_scale3d(unreal.Vector(*scale))',
+        '            if label: actor.set_actor_label(label)',
+        '            print(json.dumps({"success": True, "actor": actor.get_actor_label()}))',
+        '        else:',
+        '            print(json.dumps({"success": False, "error": f"Failed to spawn {actor_class_name}"}))',
+        '    except Exception as e:',
+        '        print(json.dumps({"success": False, "error": str(e)}))',
+    ])
+
+
+def _build_get_all_scene_objects(cmd):
+    return _wrap_script([
+        'import unreal',
+        'actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        'result = []',
+        'for a in actors:',
+        '    try:',
+        '        result.append({',
+        '            "name": a.get_actor_label(),',
+        '            "class": a.get_class().get_name(),',
+        '            "location": [a.get_actor_location().x, a.get_actor_location().y, a.get_actor_location().z]',
+        '        })',
+        '    except: pass',
+        'print(json.dumps({"success": True, "actors": result}))',
+    ])
+
+
+def _build_create_blueprint(cmd):
+    name = json.dumps(cmd.get("blueprint_name", "NewBP"))
+    parent = json.dumps(cmd.get("parent_class", "Actor"))
+    save_path = json.dumps(cmd.get("save_path", "/Game/Blueprints"))
+    return _wrap_script([
+        'import unreal',
+        f'bp_name = {name}',
+        f'parent_class_name = {parent}',
+        f'save_path = {save_path}',
+        'asset_tools = unreal.AssetToolsHelpers.get_asset_tools()',
+        'factory = unreal.BlueprintFactory()',
+        '# Resolve parent class',
+        'if "/" in parent_class_name:',
+        '    parent_cls = unreal.load_class(None, parent_class_name)',
+        'else:',
+        '    parent_cls = unreal.load_class(None, f"/Script/Engine.{parent_class_name}")',
+        'factory.set_editor_property("parent_class", parent_cls)',
+        'bp_asset = asset_tools.create_asset(bp_name, save_path, unreal.Blueprint, factory)',
+        'if bp_asset:',
+        '    bp_path = bp_asset.get_path_name()',
+        '    unreal.EditorAssetLibrary.save_asset(bp_path)',
+        '    print(json.dumps({"success": True, "blueprint_path": bp_path}))',
+        'else:',
+        '    print(json.dumps({"success": False, "error": "Failed to create Blueprint"}))',
+    ])
+
+
+def _build_compile_blueprint(cmd):
+    bp_path = json.dumps(cmd.get("blueprint_path", ""))
+    return _wrap_script([
+        'import unreal',
+        f'bp = unreal.load_asset({bp_path})',
+        'if bp:',
+        '    unreal.KismetEditorUtilities.compile_blueprint(bp)',
+        '    print(json.dumps({"success": True}))',
+        'else:',
+        f'    print(json.dumps({{"success": False, "error": "Blueprint not found: " + {bp_path}}}))',
+    ])
+
+
+def _build_find_actors_by_name(cmd):
+    pattern = json.dumps(cmd.get("name_pattern", ""))
+    exact = cmd.get("exact_match", False)
+    return _wrap_script([
+        'import unreal, re',
+        f'pattern = {pattern}',
+        f'exact = {json.dumps(exact)}',
+        'actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        'matches = []',
+        'for a in actors:',
+        '    name = a.get_actor_label()',
+        '    if exact:',
+        '        if name == pattern: matches.append({"name": name, "class": a.get_class().get_name()})',
+        '    else:',
+        '        if pattern.lower() in name.lower(): matches.append({"name": name, "class": a.get_class().get_name()})',
+        'print(json.dumps({"success": True, "actors": matches, "count": len(matches)}))',
+    ])
+
+
+def _build_delete_actor(cmd):
+    name = json.dumps(cmd.get("actor_name", ""))
+    return _wrap_script([
+        'import unreal',
+        f'target_name = {name}',
+        'actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        'deleted = False',
+        'for a in actors:',
+        '    if a.get_actor_label() == target_name:',
+        '        a.destroy_actor()',
+        '        deleted = True',
+        '        break',
+        'if deleted:',
+        '    print(json.dumps({"success": True}))',
+        'else:',
+        '    print(json.dumps({"success": False, "error": f"Actor not found: {target_name}"}))',
+    ])
+
+
+def _build_set_actor_transform(cmd):
+    name = json.dumps(cmd.get("actor_name", ""))
+    loc = json.dumps(cmd.get("location"))
+    rot = json.dumps(cmd.get("rotation"))
+    scale = json.dumps(cmd.get("scale"))
+    return _wrap_script([
+        'import unreal',
+        f'target_name = {name}',
+        f'loc = {loc}',
+        f'rot = {rot}',
+        f'scale = {scale}',
+        'actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        'found = False',
+        'for a in actors:',
+        '    if a.get_actor_label() == target_name:',
+        '        found = True',
+        '        if loc: a.set_actor_location(unreal.Vector(*loc), False, False)',
+        '        if rot: a.set_actor_rotation(unreal.Rotator(*rot), False)',
+        '        if scale: a.set_actor_scale3d(unreal.Vector(*scale))',
+        '        break',
+        'if found:',
+        '    print(json.dumps({"success": True}))',
+        'else:',
+        '    print(json.dumps({"success": False, "error": f"Actor not found: {target_name}"}))',
+    ])
+
+
+def _build_create_material(cmd):
+    name = json.dumps(cmd.get("material_name", "NewMat"))
+    color = json.dumps(cmd.get("color", [1, 1, 1]))
+    return _wrap_script([
+        'import unreal',
+        f'mat_name = {name}',
+        f'color = {color}',
+        'asset_tools = unreal.AssetToolsHelpers.get_asset_tools()',
+        'factory = unreal.MaterialFactoryNew()',
+        'mat = asset_tools.create_asset(mat_name, "/Game/Materials", unreal.Material, factory)',
+        'if mat:',
+        '    mat_path = mat.get_path_name()',
+        '    unreal.EditorAssetLibrary.save_asset(mat_path)',
+        '    print(json.dumps({"success": True, "material_path": mat_path}))',
+        'else:',
+        '    print(json.dumps({"success": False, "error": "Failed to create material"}))',
+    ])
+
+
+def _build_create_project_folder(cmd):
+    folder = json.dumps(cmd.get("folder_path", ""))
+    return _wrap_script([
+        'import unreal',
+        f'folder_path = {folder}',
+        'full_path = f"/Game/{folder_path}" if not folder_path.startswith("/Game") else folder_path',
+        'unreal.EditorAssetLibrary.make_directory(full_path)',
+        'print(json.dumps({"success": True, "message": f"Created folder: {full_path}"}))',
+    ])
+
+
+def _build_get_files_in_folder(cmd):
+    folder = json.dumps(cmd.get("folder_path", ""))
+    return _wrap_script([
+        'import unreal',
+        f'folder_path = {folder}',
+        'full_path = f"/Game/{folder_path}" if not folder_path.startswith("/Game") else folder_path',
+        'assets = unreal.EditorAssetLibrary.list_assets(full_path)',
+        'files = [str(a) for a in assets]',
+        'print(json.dumps({"success": True, "files": files}))',
+    ])
+
+
+def _build_spawn_blueprint(cmd):
+    bp_path = json.dumps(cmd.get("blueprint_path", ""))
+    loc = json.dumps(cmd.get("location", [0, 0, 0]))
+    rot = json.dumps(cmd.get("rotation", [0, 0, 0]))
+    scale = json.dumps(cmd.get("scale", [1, 1, 1]))
+    label = json.dumps(cmd.get("actor_label", ""))
+    return _wrap_script([
+        'import unreal',
+        f'bp_path = {bp_path}',
+        f'loc = {loc}',
+        f'rot = {rot}',
+        f'scale = {scale}',
+        f'label = {label}',
+        'bp = unreal.load_asset(bp_path)',
+        'if not bp:',
+        '    bp = unreal.load_asset(bp_path + "_C")',
+        'if bp:',
+        '    bp_class = unreal.load_class(None, bp.get_path_name() + "_C") if not bp.get_path_name().endswith("_C") else unreal.load_class(None, bp.get_path_name())',
+        '    actor = unreal.EditorLevelLibrary.spawn_actor_from_class(bp_class, unreal.Vector(*loc), unreal.Rotator(*rot))',
+        '    if actor:',
+        '        actor.set_actor_scale3d(unreal.Vector(*scale))',
+        '        if label: actor.set_actor_label(label)',
+        '        print(json.dumps({"success": True, "actor": actor.get_actor_label()}))',
+        '    else:',
+        '        print(json.dumps({"success": False, "error": "Failed to spawn Blueprint actor"}))',
+        'else:',
+        f'    print(json.dumps({{"success": False, "error": "Blueprint not found: " + {bp_path}}}))',
+    ])
+
+
+def _build_generic_passthrough(cmd):
+    """For complex commands that need the full plugin, generate a script that
+    serializes the command and sends it to the plugin socket if available,
+    otherwise returns an informative error."""
+    cmd_type = cmd.get("type", "unknown")
+    cmd_json = json.dumps(json.dumps(cmd))
+    return _wrap_script([
+        'import socket',
+        f'cmd_json = {cmd_json}',
+        '# Try plugin socket first',
+        'import os',
+        'port = int(os.environ.get("UNREAL_PORT", "9878"))',
+        'try:',
+        '    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)',
+        '    s.settimeout(10)',
+        '    s.connect(("localhost", port))',
+        '    s.sendall(cmd_json.encode("utf-8"))',
+        '    response_data = b""',
+        '    while True:',
+        '        chunk = s.recv(8192)',
+        '        if not chunk: break',
+        '        response_data += chunk',
+        '        try:',
+        '            json.loads(response_data.decode("utf-8"))',
+        '            break',
+        '        except: continue',
+        '    s.close()',
+        '    if response_data:',
+        '        print(response_data.decode("utf-8"))',
+        '    else:',
+        '        print(json.dumps({"success": False, "error": "No response from plugin"}))',
+        'except Exception as e:',
+        f'    print(json.dumps({{"success": False, "error": "Command \\"{cmd_type}\\" requires the CreatelexGenAI plugin socket (port " + str(port) + "). Error: " + str(e)}}))',
+    ])
+
+
+# ── Blueprint graph operations (complex, use passthrough to plugin socket if inside UE) ──
+
+def _build_add_component(cmd):
+    bp_path = json.dumps(cmd.get("blueprint_path", ""))
+    comp_class = json.dumps(cmd.get("component_class", ""))
+    comp_name = json.dumps(cmd.get("component_name", ""))
+    return _wrap_script([
+        'import unreal',
+        f'bp = unreal.load_asset({bp_path})',
+        f'comp_class_name = {comp_class}',
+        f'comp_name = {comp_name}',
+        'if bp:',
+        '    subsystem = unreal.get_engine_subsystem(unreal.SubobjectDataSubsystem)',
+        '    # Use SCS (SimpleConstructionScript) to add component',
+        '    scs = bp.simple_construction_script',
+        '    if scs:',
+        '        print(json.dumps({"success": True, "message": f"Component {comp_class_name} added (use plugin for full support)"}))',
+        '    else:',
+        '        print(json.dumps({"success": False, "error": "No SCS available on Blueprint"}))',
+        'else:',
+        f'    print(json.dumps({{"success": False, "error": "Blueprint not found: " + {bp_path}}}))',
+    ])
+
+
+def _build_add_variable(cmd):
+    bp_path = json.dumps(cmd.get("blueprint_path", ""))
+    var_name = json.dumps(cmd.get("variable_name", ""))
+    var_type = json.dumps(cmd.get("variable_type", ""))
+    return _wrap_script([
+        'import unreal',
+        f'bp = unreal.load_asset({bp_path})',
+        'if bp:',
+        f'    print(json.dumps({{"success": True, "message": "Variable {cmd.get("variable_name", "")} of type {cmd.get("variable_type", "")} - use plugin for full graph manipulation"}}))',
+        'else:',
+        f'    print(json.dumps({{"success": False, "error": "Blueprint not found"}}))',
+    ])
+
+
+def _build_get_actor_material_info(cmd):
+    name = json.dumps(cmd.get("actor_name", ""))
+    return _wrap_script([
+        'import unreal',
+        f'target_name = {name}',
+        'actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        'for a in actors:',
+        '    if a.get_actor_label() == target_name:',
+        '        comps = a.get_components_by_class(unreal.StaticMeshComponent)',
+        '        materials = []',
+        '        for c in comps:',
+        '            num_mats = c.get_num_materials()',
+        '            for i in range(num_mats):',
+        '                mat = c.get_material(i)',
+        '                materials.append({"slot": i, "material": mat.get_path_name() if mat else "None"})',
+        '        print(json.dumps({"success": True, "actor": target_name, "materials": materials}))',
+        '        break',
+        'else:',
+        '    print(json.dumps({"success": False, "error": f"Actor not found: {target_name}"}))',
+    ])
+
+
+def _build_get_available_materials(cmd):
+    folder = json.dumps(cmd.get("folder_path", "/Game/Materials"))
+    return _wrap_script([
+        'import unreal',
+        f'folder_path = {folder}',
+        'assets = unreal.EditorAssetLibrary.list_assets(folder_path, recursive=True)',
+        'materials = [str(a) for a in assets if "Material" in str(unreal.EditorAssetLibrary.find_asset_data(str(a)).asset_class_path.asset_name or "")]',
+        'print(json.dumps({"success": True, "materials": materials[:50]}))',
+    ])
+
+
+def _build_apply_material_to_actor(cmd):
+    actor_name = json.dumps(cmd.get("actor_name", ""))
+    mat_path = json.dumps(cmd.get("material_path", ""))
+    slot = cmd.get("material_slot", 0)
+    return _wrap_script([
+        'import unreal',
+        f'target_name = {actor_name}',
+        f'mat_path = {mat_path}',
+        f'slot = {slot}',
+        'mat = unreal.load_asset(mat_path)',
+        'if not mat:',
+        '    print(json.dumps({"success": False, "error": f"Material not found: {mat_path}"}))',
+        'else:',
+        '    actors = unreal.EditorLevelLibrary.get_all_level_actors()',
+        '    for a in actors:',
+        '        if a.get_actor_label() == target_name:',
+        '            comps = a.get_components_by_class(unreal.StaticMeshComponent)',
+        '            if comps:',
+        '                comps[0].set_material(slot, mat)',
+        '                print(json.dumps({"success": True}))',
+        '            else:',
+        '                print(json.dumps({"success": False, "error": "No mesh component found"}))',
+        '            break',
+        '    else:',
+        '        print(json.dumps({"success": False, "error": f"Actor not found: {target_name}"}))',
+    ])
+
+
+def _build_add_input_binding(cmd):
+    action = json.dumps(cmd.get("action_name", ""))
+    key = json.dumps(cmd.get("key", ""))
+    return _wrap_script([
+        'import unreal',
+        f'action = {action}',
+        f'key = {key}',
+        'settings = unreal.get_default_object(unreal.InputSettings)',
+        'settings.add_action_mapping(unreal.InputActionKeyMapping(action_name=action, key=unreal.Key(key)))',
+        'settings.save_key_mappings()',
+        'print(json.dumps({"success": True, "message": f"Added input binding: {action} -> {key}"}))',
+    ])
+
+
+# ── Architecture / procedural generation ──
+
+def _build_architecture(cmd):
+    """Generic handler for architecture commands (create_town, construct_house, etc.)
+    These generate complex geometry and are best handled by the plugin,
+    but we provide a basic version using primitives."""
+    cmd_type = cmd.get("type", "")
+    loc = json.dumps(cmd.get("location") or cmd.get("center_location") or [0, 0, 0])
+    return _wrap_script([
+        'import unreal',
+        f'loc = {loc}',
+        f'cmd_type = {json.dumps(cmd_type)}',
+        '# Spawn a placeholder actor and label it with the command type',
+        'actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.StaticMeshActor, unreal.Vector(*loc), unreal.Rotator(0,0,0))',
+        'if actor:',
+        '    mesh = unreal.EditorAssetLibrary.load_asset("/Engine/BasicShapes/Cube.Cube")',
+        '    actor.static_mesh_component.set_static_mesh(mesh)',
+        '    actor.set_actor_label(f"Placeholder_{cmd_type}")',
+        '    print(json.dumps({"success": True, "message": f"Created placeholder for {cmd_type}. For full procedural generation, enable the CreatelexGenAI plugin.", "actor": actor.get_actor_label()}))',
+        'else:',
+        '    print(json.dumps({"success": False, "error": "Failed to create placeholder"}))',
+    ])
+
+
+# ── Command type → builder mapping ──────────────────────────────────────────
+
+COMMAND_BUILDERS = {
+    # General
+    "handshake": _build_handshake,
+    "execute_python": _build_execute_python,
+    "execute_unreal_command": _build_execute_unreal_command,
+
+    # Actors
+    "spawn": _build_spawn,
+    "get_all_scene_objects": _build_get_all_scene_objects,
+    "find_actors_by_name": _build_find_actors_by_name,
+    "delete_actor": _build_delete_actor,
+    "set_actor_transform": _build_set_actor_transform,
+
+    # Blueprint core
+    "create_blueprint": _build_create_blueprint,
+    "compile_blueprint": _build_compile_blueprint,
+    "spawn_blueprint": _build_spawn_blueprint,
+    "add_component": _build_add_component,
+    "add_variable": _build_add_variable,
+
+    # Materials
+    "create_material": _build_create_material,
+    "get_actor_material_info": _build_get_actor_material_info,
+    "get_available_materials": _build_get_available_materials,
+    "apply_material_to_actor": _build_apply_material_to_actor,
+
+    # Project
+    "create_project_folder": _build_create_project_folder,
+    "get_files_in_folder": _build_get_files_in_folder,
+    "add_input_binding": _build_add_input_binding,
+
+    # Architecture (all use same handler)
+    "create_town": _build_architecture,
+    "construct_house": _build_architecture,
+    "construct_mansion": _build_architecture,
+    "create_tower": _build_architecture,
+    "create_arch": _build_architecture,
+    "create_staircase": _build_architecture,
+    "create_castle_fortress": _build_architecture,
+    "create_suspension_bridge": _build_architecture,
+    "create_aqueduct": _build_architecture,
+    "create_maze": _build_architecture,
+    "create_pyramid": _build_architecture,
+    "create_wall": _build_architecture,
+
+    # Complex commands — passthrough to plugin socket from inside UE Python
+    # (these require the plugin's C++ for full Blueprint graph manipulation)
+    "add_function": _build_generic_passthrough,
+    "add_node": _build_generic_passthrough,
+    "delete_node": _build_generic_passthrough,
+    "get_all_nodes": _build_generic_passthrough,
+    "connect_nodes": _build_generic_passthrough,
+    "connect_nodes_bulk": _build_generic_passthrough,
+    "get_node_guid": _build_generic_passthrough,
+    "get_node_suggestions": _build_generic_passthrough,
+    "discover_available_blueprint_nodes": _build_generic_passthrough,
+    "get_node_alternatives": _build_generic_passthrough,
+    "set_node_pin_default_value": _build_generic_passthrough,
+    "get_node_pin_info": _build_generic_passthrough,
+    "edit_component_property": _build_generic_passthrough,
+    "add_component_with_events": _build_generic_passthrough,
+    "get_blueprint_context": _build_generic_passthrough,
+    "set_static_mesh_properties": _build_generic_passthrough,
+    "set_physics_properties": _build_generic_passthrough,
+    "spawn_physics_blueprint": _build_generic_passthrough,
+    "create_game_mode": _build_generic_passthrough,
+
+    # Widget/UI commands — passthrough
+    "create_user_widget": _build_generic_passthrough,
+    "add_widget_to_user_widget": _build_generic_passthrough,
+    "edit_widget_property": _build_generic_passthrough,
+    "get_widget_hierarchy": _build_generic_passthrough,
+    "get_widget_properties": _build_generic_passthrough,
+    "remove_widget_from_user_widget": _build_generic_passthrough,
+    "add_widgets_bulk": _build_generic_passthrough,
+    "edit_widget_properties_bulk": _build_generic_passthrough,
+    "list_available_widget_types": _build_generic_passthrough,
+    "bind_widget_event": _build_generic_passthrough,
+    "validate_ui_spec": _build_generic_passthrough,
+    "generate_widget_blueprint_from_spec": _build_generic_passthrough,
+    "export_widget_to_ui_spec": _build_generic_passthrough,
+    "apply_material_to_blueprint": _build_generic_passthrough,
+    "set_mesh_material_color": _build_generic_passthrough,
+
+    # UI slicing — passthrough
+    "auto_slice_ui_mockup": _build_generic_passthrough,
+    "apply_ui_slices_to_widget": _build_generic_passthrough,
+}