unreal-engine-mcp-server 0.5.1 → 0.5.2

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpAutomationBridge_BlueprintGraphHandlers.cpp

@@ -40,19 +40,27 @@
 #endif
 
 /**
- * Process a "manage_blueprint_graph" automation request to inspect or modify a Blueprint graph.
+ * Process a "manage_blueprint_graph" automation request to inspect or modify a
+ * Blueprint graph.
  *
- * The Payload JSON controls the specific operation via the "subAction" field (examples: create_node,
- * connect_pins, get_nodes, break_pin_links, delete_node, create_reroute_node, set_node_property,
- * get_node_details, get_graph_details, get_pin_details). In editor builds this function performs
- * graph/blueprint lookups and edits; in non-editor builds it reports an editor-only error.
+ * The Payload JSON controls the specific operation via the "subAction" field
+ * (examples: create_node, connect_pins, get_nodes, break_pin_links,
+ * delete_node, create_reroute_node, set_node_property, get_node_details,
+ * get_graph_details, get_pin_details). In editor builds this function performs
+ * graph/blueprint lookups and edits; in non-editor builds it reports an
+ * editor-only error.
  *
- * @param RequestId Unique identifier for the automation request (used in responses).
- * @param Action The requested action name; this handler only processes "manage_blueprint_graph".
- * @param Payload JSON object containing action options such as "assetPath"/"blueprintPath", "graphName",
- *        "subAction" and subaction-specific fields (nodeType, nodeId, pin names, positions, etc.).
- * @param RequestingSocket WebSocket used to send responses and errors back to the requester.
- * @return `true` if the request was handled by this function (Action == "manage_blueprint_graph"), `false` otherwise.
+ * @param RequestId Unique identifier for the automation request (used in
+ * responses).
+ * @param Action The requested action name; this handler only processes
+ * "manage_blueprint_graph".
+ * @param Payload JSON object containing action options such as
+ * "assetPath"/"blueprintPath", "graphName", "subAction" and subaction-specific
+ * fields (nodeType, nodeId, pin names, positions, etc.).
+ * @param RequestingSocket WebSocket used to send responses and errors back to
+ * the requester.
+ * @return `true` if the request was handled by this function (Action ==
+ * "manage_blueprint_graph"), `false` otherwise.
  */
 bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
     const FString &RequestId, const FString &Action,
@@ -339,76 +347,39 @@ bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
       return true;
     }
 
-    // Basic node creation logic - this can be expanded significantly
-    if (NodeType == TEXT("InputAxisEvent")) {
-      FString InputAxisName;
-      Payload->TryGetStringField(TEXT("inputAxisName"), InputAxisName);
+    // ========================================================================
+    // DYNAMIC NODE CREATION - Find node classes at runtime
+    // ========================================================================
 
-      if (InputAxisName.IsEmpty()) {
-        SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("inputAxisName required"),
-                            TEXT("INVALID_ARGUMENT"));
-        return true;
-      }
-
-      FGraphNodeCreator<UK2Node_InputAxisEvent> NodeCreator(*TargetGraph);
-      UK2Node_InputAxisEvent *InputNode = NodeCreator.CreateNode(false);
-      InputNode->InputAxisName = FName(*InputAxisName);
+    // Helper: Try to find a UK2Node subclass by name
+    auto FindNodeClassByName = [](const FString &TypeName) -> UClass * {
+      TArray<FString> NamesToTry;
+      NamesToTry.Add(TypeName);
+      NamesToTry.Add(FString::Printf(TEXT("K2Node_%s"), *TypeName));
+      NamesToTry.Add(FString::Printf(TEXT("UK2Node_%s"), *TypeName));
 
-      FinalizeAndReport(NodeCreator, InputNode);
-    } else if (NodeType == TEXT("CallFunction") ||
-               NodeType == TEXT("K2Node_CallFunction") ||
-               NodeType == TEXT("FunctionCall")) {
-      FString MemberName;
-      Payload->TryGetStringField(TEXT("memberName"), MemberName);
-      FString MemberClass;
-      Payload->TryGetStringField(TEXT("memberClass"),
-                                 MemberClass); // Optional, for static functions
+      for (TObjectIterator<UClass> It; It; ++It) {
+        if (!It->IsChildOf(UEdGraphNode::StaticClass()))
+          continue;
+        if (It->HasAnyClassFlags(CLASS_Abstract))
+          continue;
 
-      UFunction *Func = nullptr;
-      if (!MemberClass.IsEmpty()) {
-        UClass *Class = ResolveUClass(MemberClass);
-        if (Class) {
-          Func = Class->FindFunctionByName(*MemberName);
-        }
-      } else {
-        // Try to find in blueprint context
-        Func = Blueprint->GeneratedClass->FindFunctionByName(*MemberName);
-        if (!Func) {
-          // Try global search if simple name, or check common libraries
-          Func = FindObject<UFunction>(nullptr, *MemberName);
-          if (!Func) {
-            // Fallback: Check common libraries
-            if (UClass *KSL = UKismetSystemLibrary::StaticClass())
-              Func = KSL->FindFunctionByName(*MemberName);
-            if (!Func)
-              if (UClass *GPS = UGameplayStatics::StaticClass())
-                Func = GPS->FindFunctionByName(*MemberName);
-            if (!Func)
-              if (UClass *KML = UKismetMathLibrary::StaticClass())
-                Func = KML->FindFunctionByName(*MemberName);
+        FString ClassName = It->GetName();
+        for (const FString &NameToMatch : NamesToTry) {
+          if (ClassName.Equals(NameToMatch, ESearchCase::IgnoreCase)) {
+            return *It;
           }
         }
       }
+      return nullptr;
+    };
 
-      if (Func) {
-        FGraphNodeCreator<UK2Node_CallFunction> NodeCreator(*TargetGraph);
-        UK2Node_CallFunction *CallFuncNode = NodeCreator.CreateNode(false);
-        CallFuncNode->SetFromFunction(Func);
-        FinalizeAndReport(NodeCreator, CallFuncNode);
-      } else {
-        SendAutomationError(
-            RequestingSocket, RequestId,
-            FString::Printf(TEXT("Could not find function '%s'"), *MemberName),
-            TEXT("FUNCTION_NOT_FOUND"));
-        return true;
-      }
-    } else if (NodeType == TEXT("VariableGet")) {
+    // Special nodes requiring extra parameters
+    if (NodeType == TEXT("VariableGet") ||
+        NodeType == TEXT("K2Node_VariableGet")) {
       FString VarName;
       Payload->TryGetStringField(TEXT("variableName"), VarName);
       FName VarFName(*VarName);
-
-      // Validation BEFORE creation
       bool bFound = false;
       for (const FBPVariableDescription &VarDesc : Blueprint->NewVariables) {
         if (VarDesc.VarName == VarFName) {
@@ -420,25 +391,25 @@ bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
           Blueprint->GeneratedClass->FindPropertyByName(VarFName)) {
         bFound = true;
       }
-
       if (!bFound) {
         SendAutomationError(
             RequestingSocket, RequestId,
-            FString::Printf(TEXT("Could not find variable '%s'"), *VarName),
+            FString::Printf(TEXT("Variable '%s' not found"), *VarName),
             TEXT("VARIABLE_NOT_FOUND"));
         return true;
       }
-
       FGraphNodeCreator<UK2Node_VariableGet> NodeCreator(*TargetGraph);
       UK2Node_VariableGet *VarGet = NodeCreator.CreateNode(false);
       VarGet->VariableReference.SetSelfMember(VarFName);
       FinalizeAndReport(NodeCreator, VarGet);
-    } else if (NodeType == TEXT("VariableSet")) {
+      return true;
+    }
+
+    if (NodeType == TEXT("VariableSet") ||
+        NodeType == TEXT("K2Node_VariableSet")) {
       FString VarName;
       Payload->TryGetStringField(TEXT("variableName"), VarName);
       FName VarFName(*VarName);
-
-      // Validation BEFORE creation
       bool bFound = false;
       for (const FBPVariableDescription &VarDesc : Blueprint->NewVariables) {
         if (VarDesc.VarName == VarFName) {
@@ -450,97 +421,89 @@ bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
           Blueprint->GeneratedClass->FindPropertyByName(VarFName)) {
         bFound = true;
       }
-
       if (!bFound) {
         SendAutomationError(
             RequestingSocket, RequestId,
-            FString::Printf(TEXT("Could not find variable '%s'"), *VarName),
+            FString::Printf(TEXT("Variable '%s' not found"), *VarName),
             TEXT("VARIABLE_NOT_FOUND"));
         return true;
       }
-
       FGraphNodeCreator<UK2Node_VariableSet> NodeCreator(*TargetGraph);
       UK2Node_VariableSet *VarSet = NodeCreator.CreateNode(false);
       VarSet->VariableReference.SetSelfMember(VarFName);
       FinalizeAndReport(NodeCreator, VarSet);
-    } else if (NodeType == TEXT("CustomEvent")) {
-      FString EventName;
-      Payload->TryGetStringField(TEXT("eventName"), EventName);
-
-      FGraphNodeCreator<UK2Node_CustomEvent> NodeCreator(*TargetGraph);
-      UK2Node_CustomEvent *EventNode = NodeCreator.CreateNode(false);
+      return true;
+    }
 
-      EventNode->CustomFunctionName = FName(*EventName);
-      FinalizeAndReport(NodeCreator, EventNode);
-    } else if (NodeType == TEXT("Event") || NodeType == TEXT("K2Node_Event")) {
-      FString EventName;
-      Payload->TryGetStringField(
-          TEXT("eventName"),
-          EventName); // e.g., "ReceiveBeginPlay", "ReceiveTick"
-      FString MemberClass;
-      Payload->TryGetStringField(TEXT("memberClass"),
-                                 MemberClass); // Optional class override
+    if (NodeType == TEXT("CallFunction") ||
+        NodeType == TEXT("K2Node_CallFunction") ||
+        NodeType == TEXT("FunctionCall")) {
+      FString MemberName, MemberClass;
+      Payload->TryGetStringField(TEXT("memberName"), MemberName);
+      Payload->TryGetStringField(TEXT("memberClass"), MemberClass);
+      UFunction *Func = nullptr;
+      if (!MemberClass.IsEmpty()) {
+        if (UClass *Class = ResolveUClass(MemberClass))
+          Func = Class->FindFunctionByName(*MemberName);
+      } else {
+        Func = Blueprint->GeneratedClass->FindFunctionByName(*MemberName);
+        if (!Func) {
+          if (UClass *KSL = UKismetSystemLibrary::StaticClass())
+            Func = KSL->FindFunctionByName(*MemberName);
+          if (!Func)
+            if (UClass *GPS = UGameplayStatics::StaticClass())
+              Func = GPS->FindFunctionByName(*MemberName);
+          if (!Func)
+            if (UClass *KML = UKismetMathLibrary::StaticClass())
+              Func = KML->FindFunctionByName(*MemberName);
+        }
+      }
+      if (Func) {
+        FGraphNodeCreator<UK2Node_CallFunction> NodeCreator(*TargetGraph);
+        UK2Node_CallFunction *CallFuncNode = NodeCreator.CreateNode(false);
+        CallFuncNode->SetFromFunction(Func);
+        FinalizeAndReport(NodeCreator, CallFuncNode);
+      } else {
+        SendAutomationError(
+            RequestingSocket, RequestId,
+            FString::Printf(TEXT("Function '%s' not found"), *MemberName),
+            TEXT("FUNCTION_NOT_FOUND"));
+      }
+      return true;
+    }
 
+    if (NodeType == TEXT("Event") || NodeType == TEXT("K2Node_Event")) {
+      FString EventName, MemberClass;
+      Payload->TryGetStringField(TEXT("eventName"), EventName);
+      Payload->TryGetStringField(TEXT("memberClass"), MemberClass);
       if (EventName.IsEmpty()) {
         SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("eventName required for Event node"),
+                            TEXT("eventName required"),
                             TEXT("INVALID_ARGUMENT"));
         return true;
       }
-
-      // Map common event name aliases to their actual function names
-      static TMap<FString, FString> EventNameAliases = {
+      static TMap<FString, FString> Aliases = {
           {TEXT("BeginPlay"), TEXT("ReceiveBeginPlay")},
           {TEXT("Tick"), TEXT("ReceiveTick")},
-          {TEXT("EndPlay"), TEXT("ReceiveEndPlay")},
-          {TEXT("ActorBeginOverlap"), TEXT("ReceiveActorBeginOverlap")},
-          {TEXT("ActorEndOverlap"), TEXT("ReceiveActorEndOverlap")},
-          {TEXT("Hit"), TEXT("ReceiveHit")},
-          {TEXT("BeginCursorOver"), TEXT("ReceiveBeginCursorOver")},
-          {TEXT("EndCursorOver"), TEXT("ReceiveEndCursorOver")},
-          {TEXT("Clicked"), TEXT("ReceiveClicked")},
-          {TEXT("Released"), TEXT("ReceiveReleased")},
-          {TEXT("Destroyed"), TEXT("ReceiveDestroyed")},
-      };
-
-      if (const FString *Alias = EventNameAliases.Find(EventName)) {
-        EventName = *Alias;
-      }
+          {TEXT("EndPlay"), TEXT("ReceiveEndPlay")}};
+      if (const FString *A = Aliases.Find(EventName))
+        EventName = *A;
 
-      // Determine target class: use explicit MemberClass or search hierarchy
       UClass *TargetClass = nullptr;
       UFunction *EventFunc = nullptr;
-
       if (!MemberClass.IsEmpty()) {
-        // Explicit class specified
         TargetClass = ResolveUClass(MemberClass);
-        if (TargetClass) {
+        if (TargetClass)
           EventFunc = TargetClass->FindFunctionByName(*EventName);
-        }
       } else {
-        // Search up the class hierarchy starting from the Blueprint's parent
-        // class. Events like ReceiveBeginPlay are defined in AActor, not in
-        // the generated Blueprint class.
-        UClass *SearchClass = Blueprint->ParentClass;
-        while (SearchClass && !EventFunc) {
-          EventFunc = SearchClass->FindFunctionByName(
-              *EventName, EIncludeSuperFlag::ExcludeSuper);
-          if (EventFunc) {
-            TargetClass = SearchClass;
-            break;
-          }
-          SearchClass = SearchClass->GetSuperClass();
-        }
-
-        // If not found in hierarchy, try the generated class
-        if (!EventFunc && Blueprint->GeneratedClass) {
-          EventFunc = Blueprint->GeneratedClass->FindFunctionByName(*EventName);
-          if (EventFunc) {
-            TargetClass = Blueprint->GeneratedClass;
-          }
+        for (UClass *C = Blueprint->ParentClass; C && !EventFunc;
+             C = C->GetSuperClass()) {
+          EventFunc = C->FindFunctionByName(*EventName,
+                                            EIncludeSuperFlag::ExcludeSuper);
+          if (EventFunc)
+            TargetClass = C;
         }
       }
-
       if (EventFunc && TargetClass) {
         FGraphNodeCreator<UK2Node_Event> NodeCreator(*TargetGraph);
         UK2Node_Event *EventNode = NodeCreator.CreateNode(false);
@@ -548,214 +511,92 @@ bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
         EventNode->bOverrideFunction = true;
         FinalizeAndReport(NodeCreator, EventNode);
       } else {
-        // Provide helpful error message
-        FString SearchedClasses;
-        UClass *C = Blueprint->ParentClass;
-        int ClassCount = 0;
-        while (C && ClassCount < 5) {
-          if (!SearchedClasses.IsEmpty())
-            SearchedClasses += TEXT(", ");
-          SearchedClasses += C->GetName();
-          C = C->GetSuperClass();
-          ClassCount++;
-        }
         SendAutomationError(
             RequestingSocket, RequestId,
-            FString::Printf(TEXT("Could not find event '%s'. Searched classes: "
-                                 "%s. Try using the full name like "
-                                 "'ReceiveBeginPlay' instead of 'BeginPlay'."),
-                            *EventName, *SearchedClasses),
+            FString::Printf(TEXT("Event '%s' not found"), *EventName),
             TEXT("EVENT_NOT_FOUND"));
       }
+      return true;
+    }
 
-    } else if (NodeType == TEXT("Cast") ||
-               NodeType.StartsWith(TEXT("CastTo"))) {
+    if (NodeType == TEXT("CustomEvent") ||
+        NodeType == TEXT("K2Node_CustomEvent")) {
+      FString EventName;
+      Payload->TryGetStringField(TEXT("eventName"), EventName);
+      FGraphNodeCreator<UK2Node_CustomEvent> NodeCreator(*TargetGraph);
+      UK2Node_CustomEvent *EventNode = NodeCreator.CreateNode(false);
+      EventNode->CustomFunctionName = FName(*EventName);
+      FinalizeAndReport(NodeCreator, EventNode);
+      return true;
+    }
+
+    if (NodeType == TEXT("Cast") || NodeType.StartsWith(TEXT("CastTo"))) {
       FString TargetClassName;
       Payload->TryGetStringField(TEXT("targetClass"), TargetClassName);
-
-      // If targetClass not specified, try to infer from nodeType
-      // "CastTo<ClassName>"
-      if (TargetClassName.IsEmpty() && NodeType.StartsWith(TEXT("CastTo"))) {
-        TargetClassName = NodeType.Mid(6); // Remove "CastTo" prefix
-      }
-
+      if (TargetClassName.IsEmpty() && NodeType.StartsWith(TEXT("CastTo")))
+        TargetClassName = NodeType.Mid(6);
       UClass *TargetClass = ResolveUClass(TargetClassName);
       if (!TargetClass) {
         SendAutomationError(
             RequestingSocket, RequestId,
-            FString::Printf(
-                TEXT("Could not resolve target class '%s' for Cast node"),
-                *TargetClassName),
+            FString::Printf(TEXT("Class '%s' not found"), *TargetClassName),
             TEXT("CLASS_NOT_FOUND"));
         return true;
       }
-
       FGraphNodeCreator<UK2Node_DynamicCast> NodeCreator(*TargetGraph);
       UK2Node_DynamicCast *CastNode = NodeCreator.CreateNode(false);
       CastNode->TargetType = TargetClass;
       FinalizeAndReport(NodeCreator, CastNode);
-    } else if (NodeType == TEXT("Sequence")) {
-      FGraphNodeCreator<UK2Node_ExecutionSequence> NodeCreator(*TargetGraph);
-      UK2Node_ExecutionSequence *NewNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, NewNode);
-    } else if (NodeType == TEXT("Branch") || NodeType == TEXT("IfThenElse") ||
-               NodeType == TEXT("K2Node_IfThenElse")) {
-      FGraphNodeCreator<UK2Node_IfThenElse> NodeCreator(*TargetGraph);
-      UK2Node_IfThenElse *BranchNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, BranchNode);
-    } else if (NodeType == TEXT("Literal")) {
-      // Create a literal node that can hold an object reference. This is a
-      // fully functional K2 literal node that returns the referenced asset
-      // or object when executed in the graph.
-      FString LiteralType;
-      Payload->TryGetStringField(TEXT("literalType"), LiteralType);
-      LiteralType.TrimStartAndEndInline();
-      const FString LiteralTypeLower =
-          LiteralType.IsEmpty() ? TEXT("object") : LiteralType.ToLower();
-
-      if (LiteralTypeLower == TEXT("object") ||
-          LiteralTypeLower == TEXT("asset")) {
-        FString ObjectPath;
-        Payload->TryGetStringField(TEXT("objectPath"), ObjectPath);
-        if (ObjectPath.IsEmpty()) {
-          // As a convenience, allow callers to use assetPath as the
-          // literal source when objectPath is omitted.
-          Payload->TryGetStringField(TEXT("assetPath"), ObjectPath);
-        }
-
-        if (ObjectPath.IsEmpty()) {
-          SendAutomationError(RequestingSocket, RequestId,
-                              TEXT("Literal object creation requires "
-                                   "'objectPath' or 'assetPath'."),
-                              TEXT("INVALID_LITERAL"));
-          return true;
-        }
-
-        UObject *LoadedObject = LoadObject<UObject>(nullptr, *ObjectPath);
-        if (!LoadedObject) {
-          SendAutomationError(
-              RequestingSocket, RequestId,
-              FString::Printf(TEXT("Literal object not found at path '%s'"),
-                              *ObjectPath),
-              TEXT("OBJECT_NOT_FOUND"));
-          return true;
-        }
-
-        // Create the node only after successful validation
-        FGraphNodeCreator<UK2Node_Literal> NodeCreator(*TargetGraph);
-        UK2Node_Literal *LiteralNode = NodeCreator.CreateNode(false);
-        if (!LiteralNode) {
-          SendAutomationError(RequestingSocket, RequestId,
-                              TEXT("Failed to allocate Literal node."),
-                              TEXT("CREATE_FAILED"));
-          return true;
-        }
-
-        // UK2Node_Literal stores the referenced UObject in a private
-        // member; use its public setter rather than touching the
-        // field directly so we respect engine encapsulation.
-        LiteralNode->SetObjectRef(LoadedObject);
-        FinalizeAndReport(NodeCreator, LiteralNode);
-      } else {
-        // Primitive literal support (float/int/bool/strings) can be
-        // added later by wiring value pins. For now, fail fast rather
-        // than pretending success.
-        SendAutomationError(
-            RequestingSocket, RequestId,
-            FString::Printf(TEXT("Unsupported literalType '%s' (only "
-                                 "'object'/'asset' supported)."),
-                            *LiteralType),
-            TEXT("UNSUPPORTED_LITERAL_TYPE"));
-        return true;
-      }
-    } else if (NodeType == TEXT("Comment")) {
-      FGraphNodeCreator<UEdGraphNode_Comment> NodeCreator(*TargetGraph);
-      UEdGraphNode_Comment *CommentNode = NodeCreator.CreateNode(false);
-
-      FString CommentText;
-      if (Payload->TryGetStringField(TEXT("comment"), CommentText) &&
-          !CommentText.IsEmpty()) {
-        CommentNode->NodeComment = CommentText;
-      } else {
-        CommentNode->NodeComment = TEXT("Comment");
-      }
-
-      CommentNode->NodeWidth = 400;
-      CommentNode->NodeHeight = 100;
-
-      FinalizeAndReport(NodeCreator, CommentNode);
-    } else if (NodeType == TEXT("MakeArray")) {
-      FGraphNodeCreator<UK2Node_MakeArray> NodeCreator(*TargetGraph);
-      UK2Node_MakeArray *MakeArrayNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, MakeArrayNode);
-    } else if (NodeType == TEXT("Return")) {
-      FGraphNodeCreator<UK2Node_FunctionResult> NodeCreator(*TargetGraph);
-      UK2Node_FunctionResult *ReturnNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, ReturnNode);
-    } else if (NodeType == TEXT("Self")) {
-      FGraphNodeCreator<UK2Node_Self> NodeCreator(*TargetGraph);
-      UK2Node_Self *SelfNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, SelfNode);
-    } else if (NodeType == TEXT("Select")) {
-      FGraphNodeCreator<UK2Node_Select> NodeCreator(*TargetGraph);
-      UK2Node_Select *SelectNode = NodeCreator.CreateNode(false);
-      FinalizeAndReport(NodeCreator, SelectNode);
-    } else if (NodeType == TEXT("Timeline")) {
-      FGraphNodeCreator<UK2Node_Timeline> NodeCreator(*TargetGraph);
-      UK2Node_Timeline *TimelineNode = NodeCreator.CreateNode(false);
-
-      FString TimelineName;
-      if (Payload->TryGetStringField(TEXT("timelineName"), TimelineName) &&
-          !TimelineName.IsEmpty()) {
-        TimelineNode->TimelineName = FName(*TimelineName);
-      }
+      return true;
+    }
 
-      FinalizeAndReport(NodeCreator, TimelineNode);
-    } else if (NodeType == TEXT("MakeStruct")) {
-      FString StructName;
-      Payload->TryGetStringField(TEXT("structName"), StructName);
-      if (StructName.IsEmpty()) {
+    if (NodeType == TEXT("InputAxisEvent") ||
+        NodeType == TEXT("K2Node_InputAxisEvent")) {
+      FString InputAxisName;
+      Payload->TryGetStringField(TEXT("inputAxisName"), InputAxisName);
+      if (InputAxisName.IsEmpty()) {
         SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("structName required for MakeStruct"),
+                            TEXT("inputAxisName required"),
                             TEXT("INVALID_ARGUMENT"));
         return true;
       }
-      UScriptStruct *Struct = FindObject<UScriptStruct>(nullptr, *StructName);
-      if (!Struct) {
-        SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("Struct not found"), TEXT("STRUCT_NOT_FOUND"));
-        return true;
-      }
+      FGraphNodeCreator<UK2Node_InputAxisEvent> NodeCreator(*TargetGraph);
+      UK2Node_InputAxisEvent *InputNode = NodeCreator.CreateNode(false);
+      InputNode->InputAxisName = FName(*InputAxisName);
+      FinalizeAndReport(NodeCreator, InputNode);
+      return true;
+    }
 
-      FGraphNodeCreator<UK2Node_MakeStruct> NodeCreator(*TargetGraph);
-      UK2Node_MakeStruct *MakeStructNode = NodeCreator.CreateNode(false);
-      MakeStructNode->StructType = Struct;
-      FinalizeAndReport(NodeCreator, MakeStructNode);
-    } else if (NodeType == TEXT("BreakStruct")) {
-      FString StructName;
-      Payload->TryGetStringField(TEXT("structName"), StructName);
-      if (StructName.IsEmpty()) {
-        SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("structName required for BreakStruct"),
-                            TEXT("INVALID_ARGUMENT"));
-        return true;
-      }
-      UScriptStruct *Struct = FindObject<UScriptStruct>(nullptr, *StructName);
-      if (!Struct) {
+    // ========== DYNAMIC FALLBACK: Create ANY node class by name ==========
+    UClass *NodeClass = FindNodeClassByName(NodeType);
+    if (NodeClass) {
+      UEdGraphNode *NewNode = NewObject<UEdGraphNode>(TargetGraph, NodeClass);
+      if (NewNode) {
+        TargetGraph->AddNode(NewNode, false, false);
+        NewNode->CreateNewGuid();
+        NewNode->PostPlacedNewNode();
+        NewNode->AllocateDefaultPins();
+        NewNode->NodePosX = X;
+        NewNode->NodePosY = Y;
+        FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);
+        TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+        Result->SetStringField(TEXT("nodeId"), NewNode->NodeGuid.ToString());
+        Result->SetStringField(TEXT("nodeName"), NewNode->GetName());
+        Result->SetStringField(TEXT("nodeClass"), NodeClass->GetName());
+        SendAutomationResponse(RequestingSocket, RequestId, true,
+                               TEXT("Node created."), Result);
+      } else {
         SendAutomationError(RequestingSocket, RequestId,
-                            TEXT("Struct not found"), TEXT("STRUCT_NOT_FOUND"));
-        return true;
+                            TEXT("Failed to instantiate node."),
+                            TEXT("CREATE_FAILED"));
       }
-
-      FGraphNodeCreator<UK2Node_BreakStruct> NodeCreator(*TargetGraph);
-      UK2Node_BreakStruct *BreakStructNode = NodeCreator.CreateNode(false);
-      BreakStructNode->StructType = Struct;
-      FinalizeAndReport(NodeCreator, BreakStructNode);
     } else {
       SendAutomationError(
           RequestingSocket, RequestId,
-          TEXT("Failed to create node (unsupported type or internal error)."),
-          TEXT("CREATE_FAILED"));
+          FString::Printf(TEXT("Node type '%s' not found. Use list_node_types "
+                               "to see available types."),
+                          *NodeType),
+          TEXT("NODE_TYPE_NOT_FOUND"));
     }
     return true;
   } else if (SubAction == TEXT("connect_pins")) {
@@ -1168,6 +1009,75 @@ bool UMcpAutomationBridgeSubsystem::HandleBlueprintGraphAction(
     SendAutomationResponse(RequestingSocket, RequestId, true,
                            TEXT("Pin details retrieved."), Result);
     return true;
+  } else if (SubAction == TEXT("list_node_types")) {
+    // List all available UK2Node types for AI discoverability
+    TArray<TSharedPtr<FJsonValue>> NodeTypes;
+    for (TObjectIterator<UClass> It; It; ++It) {
+      if (!It->IsChildOf(UK2Node::StaticClass()))
+        continue;
+      if (It->HasAnyClassFlags(CLASS_Abstract))
+        continue;
+
+      TSharedPtr<FJsonObject> TypeObj = MakeShared<FJsonObject>();
+      TypeObj->SetStringField(TEXT("className"), It->GetName());
+      TypeObj->SetStringField(TEXT("displayName"),
+                              It->GetDisplayNameText().ToString());
+      NodeTypes.Add(MakeShared<FJsonValueObject>(TypeObj));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetArrayField(TEXT("nodeTypes"), NodeTypes);
+    Result->SetNumberField(TEXT("count"), NodeTypes.Num());
+    SendAutomationResponse(RequestingSocket, RequestId, true,
+                           TEXT("Node types listed."), Result);
+    return true;
+  } else if (SubAction == TEXT("set_pin_default_value")) {
+    // Set a default value on a node's input pin
+    FString NodeId, PinName, Value;
+    Payload->TryGetStringField(TEXT("nodeId"), NodeId);
+    Payload->TryGetStringField(TEXT("pinName"), PinName);
+    Payload->TryGetStringField(TEXT("value"), Value);
+
+    UEdGraphNode *TargetNode = FindNodeByIdOrName(NodeId);
+    if (!TargetNode) {
+      SendAutomationError(RequestingSocket, RequestId, TEXT("Node not found."),
+                          TEXT("NODE_NOT_FOUND"));
+      return true;
+    }
+
+    UEdGraphPin *Pin = TargetNode->FindPin(*PinName);
+    if (!Pin) {
+      SendAutomationError(RequestingSocket, RequestId, TEXT("Pin not found."),
+                          TEXT("PIN_NOT_FOUND"));
+      return true;
+    }
+
+    if (Pin->Direction != EGPD_Input) {
+      SendAutomationError(RequestingSocket, RequestId,
+                          TEXT("Can only set default values on input pins."),
+                          TEXT("INVALID_PIN_DIRECTION"));
+      return true;
+    }
+
+    const FScopedTransaction Transaction(
+        FText::FromString(TEXT("Set Pin Default Value")));
+    Blueprint->Modify();
+    TargetGraph->Modify();
+    TargetNode->Modify();
+
+    // Use the schema to properly set the default value
+    const UEdGraphSchema *Schema = TargetGraph->GetSchema();
+    Schema->TrySetDefaultValue(*Pin, Value);
+
+    FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("nodeId"), NodeId);
+    Result->SetStringField(TEXT("pinName"), PinName);
+    Result->SetStringField(TEXT("value"), Value);
+    SendAutomationResponse(RequestingSocket, RequestId, true,
+                           TEXT("Pin default value set."), Result);
+    return true;
   }
 
   SendAutomationError(