Demo: connecting Jason agent to chat using XMPP

[mindcrime]

Sharing in the off chance somebody else might find this useful. What I did here was connect my Environment to an XMPP server so my agent (there's only one at the moment) can receive messages from a (presumably) human interlocutor over the XMPP chat protocol.

This is all in service of my interest in exploring more about natural language understanding and learning via dialogue, in the context of a BDI system.

Full source code can be found here but the salient bits are as follows:

Env.java

public class Env extends Environment 
{
    // common literals
    // public static final Literal of  = Literal.parseLiteral("open(fridge)");
	
    private Logger logger = Logger.getLogger( Env.class.getName() );

    WorldModel model; // the model of the grid    
    
    AbstractXMPPConnection connection = null;
    
	String xmppUsername;
	
	String xmppPassword;
	
	String xmppResource;
	
	String xmppServiceName;
	
	String xmppHost;

    
    /** Called before the MAS execution with the args informed in .mas2j */
    @Override
    public void init(String[] args) 
    {
        super.init(args);
        
        this.model = new WorldModel();
        
        xmppUsername = 		args[0];
        xmppPassword = 		args[1];
        xmppResource = 		args[2];
        xmppServiceName = 	args[3];
        xmppHost = 			args[4];
        
        try
        {
	        XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder();
			configBuilder.setUsernameAndPassword( xmppUsername, xmppPassword ); 
			configBuilder.setResource(xmppResource);
			configBuilder.setXmppDomain( xmppServiceName );
			configBuilder.setHost( xmppHost );
        
			// accept all certificate - just for testing  
			TLSUtils.acceptAllCertificates(configBuilder);
			
			connection = new XMPPTCPConnection(configBuilder.build());
        
			ConnectionListener connectionListener = new XmppConnectionListener();
			
			// make sure auto reconnect is turned on.
			ReconnectionManager.getInstanceFor(connection).enableAutomaticReconnection();
			
			BlockingQueue<String> inputMessageQueue = new LinkedBlockingQueue<String>();
			
			logger.info( "Connecting to XMPP server" );
			
			connection.addConnectionListener( connectionListener );
			
			// Connect to the )server
			connection.connect();
	
			// Log into the server
			connection.login();
			logger.info( "Logged in to XMPP server" );
			
			ChatManager chatManager = ChatManager.getInstanceFor(connection);			
			
			ChatMessageListener messageListener = new ChatMessageListener(this);
			
			chatManager.addIncomingListener( messageListener );
			
			
			
			
        }
		catch( Exception e )
		{
			logger.severe( "Error configuring XMPP connection: " + e.getMessage() );
		}
        
                
        updatePercepts();
        informAgsEnvironmentChanged();
    }

   void updatePercepts() 
    {
        // clear the percepts of the agents
        clearPercepts();

        // get messages from the model
        // and add percepts for each message
        
        Queue<XmppMessage> messages = model.getMessages();
		messages.forEach( message -> {
			addPercept( Literal.parseLiteral( "message('" + message.getFrom()
					+ "', '" + message.getMessage().getBody() + "')" ) );
		} );
        
    }
    
    public WorldModel getModel()
	{
		return this.model;
	}
    
	public void notifyNewMessage()
	{
		updatePercepts();
		informAgsEnvironmentChanged();
	}

WorldModel.java

public class WorldModel
{
    Logger logger = Logger.getLogger( WorldModel.class.getName() );
	
    Queue<XmppMessage> messages = new LinkedBlockingQueue<XmppMessage>();
    
    
    public WorldModel() 
    {   
    }

	public synchronized boolean addMessage( XmppMessage message )
	{
		logger.info( "WorldModel.addMessage: " + message );
		return messages.add( message );
	}
	
	public synchronized Queue<XmppMessage> getMessages()
	{
		Queue<XmppMessage> messagesCopy = new LinkedBlockingQueue<XmppMessage>(this.messages);
		
		this.messages.clear();
		
		return messagesCopy;
	}
	
}

ChatMessageListener.java

import org.jivesoftware.smack.chat2.Chat;
import org.jivesoftware.smack.chat2.IncomingChatMessageListener;
import org.jivesoftware.smack.packet.Message;
import org.jxmpp.jid.EntityBareJid;

import env.Env;
import model.WorldModel;

public class ChatMessageListener implements IncomingChatMessageListener
{
	Env env;
	WorldModel model;
	
	public ChatMessageListener( Env env )
	{
		this.env = env;
		this.model = env.getModel();
	}
	
	@Override
	public void newIncomingMessage( EntityBareJid from, Message message, Chat chat )
	{
		// add the newly received message to the model
		// model.addMessage( from, message.getBody() );
		XmppMessage newMessage = new XmppMessage( from, message, chat );
	
		model.addMessage( newMessage );
		
		env.notifyNewMessage();
	}
}

XmppMessage.java

import org.jivesoftware.smack.chat2.Chat;
import org.jivesoftware.smack.packet.Message;
import org.jxmpp.jid.EntityBareJid;

public class XmppMessage
{
	private EntityBareJid from;
	private Message message;
	private Chat chat;
	
	
	
	public XmppMessage( EntityBareJid from, Message message, Chat chat )
	{
		this.from = from;
		this.message = message;
		this.chat = chat;
	}
	
	public EntityBareJid getFrom()
	{
		return from;
	}
	
	public void setFrom( EntityBareJid from )
	{
		this.from = from;
	}
	
	public Message getMessage()
	{
		return message;
	}
	
	public void setMessage( Message message )
	{
		this.message = message;
	}
	
	public Chat getChat()
	{
		return chat;
	}
	
	public void setChat( Chat chat )
	{
		this.chat = chat;
	}
	
}

agent1.asl

started.

+started <- .print( "Hello, Agent1!" ).

+message(X,Y) <- .print( "Agent1 received message ", Y, " from ", X ).

xmpp-bdi-bot1.mas2j

/*
    xmpp-bdi-bot1.mas2j
    ---------------------------

    Jason Application File

    This file defines the initial state of the MAS

    Jason 3.2.0
    October 05, 2024 - 20:14:04
*/

MAS xmpp_bdi_bot1 {

    /* 
        xmpp.username=username
        xmpp.password=password
        xmpp.resource=SomeResource
        xmpp.serviceName=fogbeam.click
        xmpp.host=www.fogbeam.click
    */
    
    
    environment: env.Env( "username", "password", "SomeResource", "fogbeam.click", "www.fogbeam.click"  )

    agents: agent1;
    aslSourcePath: "src/agt";
}

Some observations:

1. This obviously doesn't do much at the moment. The point of this part of the example is really just about the mechanics of establishing the connection.

2. I'm not 100% sold that this is the correct way to go about this. Since we're in the context of a multi-agent-system environment already, and given that one could argue that humans are also agents (albeit of a very peculiar nature) it might actually make more sense to incorporate the JADE support and the messaging that's built into Jason, as opposed to using the Environment. And if this was always intended to only ever be chat based, I might well explore that. But in actuality I'm also developing hardware to run this on that includes microphones, speaker output, webcams and other sensors for getting environmental percepts. So I chose to conceptualize all human interactions as involving the environment. For now anyway. I'm open to changing my thinking on this.

3. Next steps will focus on parsing the received messages and trying to model them in terms of Speech Acts Theory performatives, and pursuing other ideas drawn from language semantics, etc. to convert the incoming message to beliefs that might either just sit in the belief base until needed, or might trigger events (like replying to the message at hand, or taking some other action) in response.

4. I'm also interested in possibly customizing the belief-base a bit. For one thing, since I want this agent to learn more or less continuously, I want a persistent belief base in case the agent system goes down for some reason. And given that my background is heavy on semantic web tech, I have at least some "mental doodles" in mind in terms of trying to store beliefs in an RDF triple-store like Jena TDB. That also gives me some reasoning/inference capabilities using OWL inference and the possibility of doing some probabilistic stuff using PR-OWL. Not yet sure how that will work out, but time will tell.

5. I have a notion of trying to model some additional mental states - things like "boredom", "confusion", ,"cognitive dissonance", "frustration", etc and have those factor into the behavior of the system. And maybe also "goals" in the sense of "high level life goals", as well as "principles", "values", "attitudes", etc. But that's getting way into "version 100+" stuff there. :-)

Anyway, enjoy and if anybody has any feedback or thoughts on any of this, I'd love to hear it (good or bad!)