unetjs 4.0.2 → 5.0.1

package/dist/esm/unet.js

@@ -1,31 +1,160 @@
-/* unet.js v4.0.2 2025-05-19T10:05:53.629Z */
+/* unet.js v5.0.1 2025-09-10T10:45:09.128Z */
 
-/* fjage.js v2.1.0 */
+/* fjage.js v2.2.2 */
 
-const isBrowser =
-  typeof window !== "undefined" && typeof window.document !== "undefined";
+/**
+* An action represented by a message. The performative actions are a subset of the
+* FIPA ACL recommendations for interagent communication.
+* @enum {string}
+*/
+const Performative = {
+  REQUEST: 'REQUEST',               // Request an action to be performed
+  AGREE: 'AGREE',                   // Agree to performing the requested action
+  REFUSE: 'REFUSE',                 // Refuse to perform the requested action
+  FAILURE: 'FAILURE',               // Notification of failure to perform a requested or agreed action
+  INFORM: 'INFORM',                 // Notification of an event
+  CONFIRM: 'CONFIRM',               // Confirm that the answer to a query is true
+  DISCONFIRM: 'DISCONFIRM',         // Confirm that the answer to a query is false
+  QUERY_IF: 'QUERY_IF',             // Query if some statement is true or false
+  NOT_UNDERSTOOD: 'NOT_UNDERSTOOD', // Notification that a message was not understood
+  CFP: 'CFP',                       // Call for proposal
+  PROPOSE: 'PROPOSE',               // Response for CFP
+  CANCEL: 'CANCEL'                  // Cancel pending request
+};
 
-const isNode =
-  typeof process !== "undefined" &&
-  process.versions != null &&
-  process.versions.node != null;
+////// common utilities
+
+// generate random ID with length 4*len characters
+/**
+ *
+ * @private
+ * @param {number} len
+ */
+function _guid(len) {
+  const s4 = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+  return Array.from({ length: len }, s4).join('');
+}
 
-const isWebWorker =
-  typeof self === "object" &&
-  self.constructor &&
-  self.constructor.name === "DedicatedWorkerGlobalScope";
 
 /**
- * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0
- * @see https://github.com/jsdom/jsdom/issues/1537
+ * A simple and lightweight implementation of UUIDv7.
+ *
+ * UUIDv7 is a time-based UUID version that is lexicographically sortable and
+ * is designed to be used as a database key.
+ *
+ * The structure is as follows:
+ * 0                   1                   2                   3
+ * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                           unix_ts_ms                          |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |          unix_ts_ms           |  ver  |      rand_a           |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |var|                        rand_b                             |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |                            rand_b                             |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *
+ * - unix_ts_ms (48 bits): Unix timestamp in milliseconds.
+ * - ver (4 bits): Version, set to 7.
+ * - rand_a (12 bits): Random data.
+ * - var (2 bits): Variant, set to '10'.
+ * - rand_b (62 bits): Random data.
  */
-const isJsDom =
-  (typeof window !== "undefined" && window.name === "nodejs") ||
-  (typeof navigator !== "undefined" &&
-    (navigator.userAgent.includes("Node.js") ||
-      navigator.userAgent.includes("jsdom")));
+class UUID7 {
+    /**
+     * Private constructor to create a UUID7 from a byte array.
+     * @param {Uint8Array} bytes The 16 bytes of the UUID.
+     */
+    constructor(bytes) {
+        if (bytes.length !== 16) {
+            throw new Error('UUID7 must be constructed with a 16-byte array.');
+        }
+        this.bytes = bytes;
+    }
+
+    /**
+     * Generates a new UUIDv7.
+     * @returns {UUID7} A new UUIDv7 instance.
+     */
+    static generate() {
+        const bytes = new Uint8Array(16);
+        const randomBytes = crypto.getRandomValues(new Uint8Array(10));
+        const timestamp = Date.now();
+
+        // Set the 48-bit timestamp
+        // JavaScript numbers are 64-bit floats, but bitwise operations treat them
+        // as 32-bit signed integers. We need to handle the 48-bit timestamp carefully.
+        const timestampHi = Math.floor(timestamp / 2 ** 16);
+        const timestampLo = timestamp % 2 ** 16;
+
+        bytes[0] = (timestampHi >> 24) & 0xff;
+        bytes[1] = (timestampHi >> 16) & 0xff;
+        bytes[2] = (timestampHi >> 8) & 0xff;
+        bytes[3] = timestampHi & 0xff;
+        bytes[4] = (timestampLo >> 8) & 0xff;
+        bytes[5] = timestampLo & 0xff;
+
+        // Copy the 10 random bytes
+        bytes.set(randomBytes, 6);
+
+        // Set the 4-bit version (0111) in byte 6
+        bytes[6] = (bytes[6] & 0x0f) | 0x70;
+
+        // Set the 2-bit variant (10) in byte 8
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+        return new UUID7(bytes);
+    }
+
+    /**
+     * Extracts the timestamp from the UUID.
+     * @returns {number} The Unix timestamp in milliseconds.
+     */
+    getTimestamp() {
+        let timestamp = 0;
+        timestamp = this.bytes[0] * 2 ** 40;
+        timestamp += this.bytes[1] * 2 ** 32;
+        timestamp += this.bytes[2] * 2 ** 24;
+        timestamp += this.bytes[3] * 2 ** 16;
+        timestamp += this.bytes[4] * 2 ** 8;
+        timestamp += this.bytes[5];
+        return timestamp;
+    }
+
+    /**
+     * Formats the UUID into the standard string representation.
+     * @returns {string} The UUID string.
+     */
+    toString() {
+        let result = '';
+        for (let i = 0; i < 16; i++) {
+            result += this.bytes[i].toString(16).padStart(2, '0');
+            if (i === 3 || i === 5 || i === 7 || i === 9) {
+                result += '-';
+            }
+        }
+        return result;
+    }
+}
 
-typeof Deno !== "undefined" && typeof Deno.core !== "undefined";
+// src/index.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = (
+  // @ts-expect-error
+  typeof process !== "undefined" && // @ts-expect-error
+  process.versions != null && // @ts-expect-error
+  process.versions.node != null
+);
+var isWebWorker = typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope";
+var isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && "userAgent" in navigator && typeof navigator.userAgent === "string" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
+(
+  // @ts-expect-error
+  typeof Deno !== "undefined" && // @ts-expect-error
+  typeof Deno.version !== "undefined" && // @ts-expect-error
+  typeof Deno.version.deno !== "undefined"
+);
+typeof process !== "undefined" && process.versions != null && process.versions.bun != null;
 
 const SOCKET_OPEN = 'open';
 const SOCKET_OPENING = 'opening';
@@ -34,20 +163,20 @@ const DEFAULT_RECONNECT_TIME$1 = 5000;       // ms, delay between retries to con
 var createConnection;
 
 /**
- * @class
- * @ignore
- */
+* @class
+* @ignore
+*/
 class TCPConnector {
 
   /**
-    * Create an TCPConnector to connect to a fjage master over TCP
-   * @param {Object} opts
-   * @param {string} [opts.hostname='localhost'] - hostname/ip address of the master container to connect to
-   * @param {number} [opts.port=1100] - port number of the master container to connect to
-   * @param {boolean} [opts.keepAlive=true] - try to reconnect if the connection is lost
-   * @param {boolean} [opts.debug=false] - debug info to be logged to console?
-   * @param {number} [opts.reconnectTime=5000] - time before reconnection is attempted after an error
-    */
+  * Create an TCPConnector to connect to a fjage master over TCP
+  * @param {Object} opts
+  * @param {string} [opts.hostname='localhost'] - hostname/ip address of the master container to connect to
+  * @param {number} [opts.port=1100] - port number of the master container to connect to
+  * @param {boolean} [opts.keepAlive=true] - try to reconnect if the connection is lost
+  * @param {boolean} [opts.debug=false] - debug info to be logged to console?
+  * @param {number} [opts.reconnectTime=5000] - time before reconnection is attempted after an error
+  */
   constructor(opts = {}) {
     let host = opts.hostname || 'localhost';
     let port = opts.port || 1100;
@@ -142,10 +271,10 @@ class TCPConnector {
   }
 
   /**
-   * Write a string to the connector
-   * @param {string} s - string to be written out of the connector to the master
-   * @return {boolean} - true if connect was able to write or queue the string to the underlying socket
-   */
+  * Write a string to the connector
+  * @param {string} s - string to be written out of the connector to the master
+  * @return {boolean} - true if connect was able to write or queue the string to the underlying socket
+  */
   write(s){
     if (!this.sock || this.sock.readyState == SOCKET_OPENING){
       this.pendingOnOpen.push(() => {
@@ -160,32 +289,32 @@ class TCPConnector {
   }
 
   /**
-   * @callback TCPConnectorReadCallback
-   * @ignore
-   * @param {string} s - incoming message string
-   */
+  * @callback TCPConnectorReadCallback
+  * @ignore
+  * @param {string} s - incoming message string
+  */
 
   /**
-   * Set a callback for receiving incoming strings from the connector
-   * @param {TCPConnectorReadCallback} cb - callback that is called when the connector gets a string
-   */
+  * Set a callback for receiving incoming strings from the connector
+  * @param {TCPConnectorReadCallback} cb - callback that is called when the connector gets a string
+  */
   setReadCallback(cb){
     if (cb && {}.toString.call(cb) === '[object Function]') this._onSockRx = cb;
   }
 
   /**
-   * Add listener for connection events
-   * @param {function} listener - a listener callback that is called when the connection is opened/closed
-   */
+  * Add listener for connection events
+  * @param {function} listener - a listener callback that is called when the connection is opened/closed
+  */
   addConnectionListener(listener){
     this.connListeners.push(listener);
   }
 
   /**
-   * Remove listener for connection events
-   * @param {function} listener - remove the listener for connection
-   * @return {boolean} - true if the listner was removed successfully
-   */
+  * Remove listener for connection events
+  * @param {function} listener - remove the listener for connection
+  * @return {boolean} - true if the listner was removed successfully
+  */
   removeConnectionListener(listener) {
     let ndx = this.connListeners.indexOf(listener);
     if (ndx >= 0) {
@@ -196,8 +325,8 @@ class TCPConnector {
   }
 
   /**
-   * Close the connector
-   */
+  * Close the connector
+  */
   close(){
     if (!this.sock) return;
     if (this.sock.readyState == SOCKET_OPENING) {
@@ -221,21 +350,21 @@ class TCPConnector {
 const DEFAULT_RECONNECT_TIME = 5000;       // ms, delay between retries to connect to the server.
 
 /**
- * @class
- * @ignore
- */
+* @class
+* @ignore
+*/
 class WSConnector {
 
   /**
-   * Create an WSConnector to connect to a fjage master over WebSockets
-   * @param {Object} opts
-   * @param {string} [opts.hostname='localhost'] - hostname/ip address of the master container to connect to
-   * @param {number} [opts.port=80] - port number of the master container to connect to
-   * @param {string} [opts.pathname="/"] - path of the master container to connect to
-   * @param {boolean} [opts.keepAlive=true] - try to reconnect if the connection is lost
-   * @param {boolean} [opts.debug=false] - debug info to be logged to console?
-   * @param {number} [opts.reconnectTime=5000] - time before reconnection is attempted after an error
-   */
+  * Create an WSConnector to connect to a fjage master over WebSockets
+  * @param {Object} opts
+  * @param {string} [opts.hostname='localhost'] - hostname/ip address of the master container to connect to
+  * @param {number} [opts.port=80] - port number of the master container to connect to
+  * @param {string} [opts.pathname="/"] - path of the master container to connect to
+  * @param {boolean} [opts.keepAlive=true] - try to reconnect if the connection is lost
+  * @param {boolean} [opts.debug=false] - debug info to be logged to console?
+  * @param {number} [opts.reconnectTime=5000] - time before reconnection is attempted after an error
+  */
   constructor(opts = {}) {
     let host = opts.hostname || 'localhost';
     let port = opts.port || 80;
@@ -300,9 +429,9 @@ class WSConnector {
   }
 
   /**
-   * Write a string to the connector
-   * @param {string} s - string to be written out of the connector to the master
-   */
+  * Write a string to the connector
+  * @param {string} s - string to be written out of the connector to the master
+  */
   write(s){
     if (!this.sock || this.sock.readyState == this.sock.CONNECTING){
       this.pendingOnOpen.push(() => {
@@ -317,33 +446,33 @@ class WSConnector {
   }
 
   /**
-   * @callback WSConnectorReadCallback
-   * @ignore
-   * @param {string} s - incoming message string
-   */
+  * @callback WSConnectorReadCallback
+  * @ignore
+  * @param {string} s - incoming message string
+  */
 
   /**
-   * Set a callback for receiving incoming strings from the connector
-   * @param {WSConnectorReadCallback} cb - callback that is called when the connector gets a string
-   * @ignore
-   */
+  * Set a callback for receiving incoming strings from the connector
+  * @param {WSConnectorReadCallback} cb - callback that is called when the connector gets a string
+  * @ignore
+  */
   setReadCallback(cb){
     if (cb && {}.toString.call(cb) === '[object Function]') this._onWebsockRx = cb;
   }
 
   /**
-   * Add listener for connection events
-   * @param {function} listener - a listener callback that is called when the connection is opened/closed
-   */
+  * Add listener for connection events
+  * @param {function} listener - a listener callback that is called when the connection is opened/closed
+  */
   addConnectionListener(listener){
     this.connListeners.push(listener);
   }
 
   /**
-   * Remove listener for connection events
-   * @param {function} listener - remove the listener for connection
-   * @return {boolean} - true if the listner was removed successfully
-   */
+  * Remove listener for connection events
+  * @param {function} listener - remove the listener for connection
+  * @return {boolean} - true if the listner was removed successfully
+  */
   removeConnectionListener(listener) {
     let ndx = this.connListeners.indexOf(listener);
     if (ndx >= 0) {
@@ -354,8 +483,8 @@ class WSConnector {
   }
 
   /**
-   * Close the connector
-   */
+  * Close the connector
+  */
   close(){
     if (!this.sock) return;
     if (this.sock.readyState == this.sock.CONNECTING) {
@@ -372,328 +501,389 @@ class WSConnector {
   }
 }
 
-/* global global Buffer */
-
-
-const DEFAULT_QUEUE_SIZE = 128;        // max number of old unreceived messages to store
+/* global Buffer */
 
 /**
- * An action represented by a message. The performative actions are a subset of the
- * FIPA ACL recommendations for interagent communication.
- * @enum {string}
- */
-const Performative = {
-  REQUEST: 'REQUEST',               // Request an action to be performed
-  AGREE: 'AGREE',                   // Agree to performing the requested action
-  REFUSE: 'REFUSE',                 // Refuse to perform the requested action
-  FAILURE: 'FAILURE',               // Notification of failure to perform a requested or agreed action
-  INFORM: 'INFORM',                 // Notification of an event
-  CONFIRM: 'CONFIRM',               // Confirm that the answer to a query is true
-  DISCONFIRM: 'DISCONFIRM',         // Confirm that the answer to a query is false
-  QUERY_IF: 'QUERY_IF',             // Query if some statement is true or false
-  NOT_UNDERSTOOD: 'NOT_UNDERSTOOD', // Notification that a message was not understood
-  CFP: 'CFP',                       // Call for proposal
-  PROPOSE: 'PROPOSE',               // Response for CFP
-  CANCEL: 'CANCEL'                  // Cancel pending request
-};
-
-/**
- * An identifier for an agent or a topic.
- * @class
- * @param {string} name - name of the agent
- * @param {boolean} [topic=false] - name of topic
- * @param {Gateway} [owner] - Gateway owner for this AgentID
- */
-class AgentID {
-
-
-  constructor(name, topic=false, owner) {
-    this.name = name;
-    this.topic = topic;
-    this.owner = owner;
-  }
+* Class representing a fjage's on-the-wire JSON message. A JSONMessage object
+* contains all the fields that can be a part of a fjage JSON message. The class
+* provides methods to create JSONMessage objects from raw strings and to
+* convert JSONMessage objects to JSON strings in the format of the fjage on-the-wire
+* protocol. See {@link https://fjage.readthedocs.io/en/latest/protocol.html#json-message-request-response-attributes fjage documentation}
+* for more details on the JSON message format.
+*
+* Most users will not need to create JSONMessage objects directly, but rather use the Gateway and Message classes
+* to send and receive messages. However, this class can be useful for low-level access to the fjage protocol
+* or for generating/consuming the fjåge protocol messages without having them be transmitted over a network.
+*
+* @example
+* const jsonMsg = new JSONMessage();
+* jsonMsg.action = 'send';
+* jsonMsg.message = new Message();
+* jsonMsg.message.sender = new AgentID('agent1');
+* jsonMsg.message.recipient = new AgentID('agent2');
+* jsonMsg.message.perf = Performative.INFORM;
+* jsonMsg.toJSON(); // Converts to JSON string in the fjage on-the-wire protocol format
+*
+* @example
+* const jsonString = '{"id":"1234",...}'; // JSON string representation of a JSONMessage
+* const jsonMsg = new JSONMessage(jsonString); // Parses the JSON string into a JSONMessage object
+* jsonMsg.message; // Access the Message object contained in the JSONMessage
+*
+* @class
+* @property {string} [id] - A UUID assigned to each JSONMessage object.
+* @property {string} [action] - Denotes the main action the object is supposed to perform.
+* @property {string} [inResponseTo] - This attribute contains the action to which this object is a response to.
+* @property {AgentID} [agentID] - An AgentID. This attribute is populated in objects which are responses to objects requesting the ID of an agent providing a specific service.
+* @property {Array<AgentID>} [agentIDs] - This attribute is populated in objects which are responses to objects requesting the IDs of agents providing a specific service, or objects which are responses to objects requesting a list of all agents running in a container.
+* @property {Array<string>} [agentTypes] - This attribute is optionally populated in objects which are responses to objects requesting a list of all agents running in a container. If populated, it contains a list of agent types running in the container, with a one-to-one mapping to the agent IDs in the "agentIDs" attribute.
+* @property {string} [service] - Used in conjunction with "action" : "agentForService" and "action" : "agentsForService" to query for agent(s) providing this specific service.
+* @property {Array<string>} [services] - This attribute is populated in objects which are responses to objects requesting the services available with "action" : "services".
+* @property {boolean} [answer] - This attribute is populated in objects which are responses to query objects with "action" : "containsAgent".
+* @property {Message} [message] - This holds the main payload of the message. The structure and format of this object is discussed in the {@link https://fjage.readthedocs.io/en/latest/protocol.html#json-message-request-response-attributes fjage documentation}.
+* @property {boolean} [relay] - This attribute defines if the target container should relay (forward) the message to other containers it is connected to or not.
+* @property {Object} [creds] - Credentials to be used for authentication.
+* @property {Object} [auth] - Authentication information to be used for the message.
+*
+*
+*/
+class JSONMessage {
 
   /**
-   * Gets the name of the agent or topic.
-   *
-   * @returns {string} - name of agent or topic
-   */
-  getName() {
-    return this.name;
-  }
+  * @param {String} [jsonString] - JSON string to be parsed into a JSONMessage object.
+  * @param {Object} [owner] - The owner of the JSONMessage object, typically the Gateway instance.
+  */
+  constructor(jsonString, owner) {
+    this.id = UUID7.generate().toString(); // unique JSON message ID
+    this.action =  null;
+    this.inResponseTo =  null;
+    this.agentID = null;
+    this.agentIDs = null;
+    this.agentTypes = null;
+    this.service =  null;
+    this.services = null;
+    this.answer =  null;
+    this.message = null;
+    this.relay =  null;
+    this.creds =  null;
+    this.auth =  null;
+    this.name =  null;
+    if (jsonString && typeof jsonString === 'string') {
+      try {
+        const parsed = JSON.parse(jsonString, _decodeBase64);
+        if (parsed.message) parsed.message = Message.fromJSON(parsed.message);
+        if (parsed.agentID) parsed.agentID = AgentID.fromJSON(parsed.agentID, owner);
+        if (parsed.agentIDs) parsed.agentIDs = parsed.agentIDs.map(id => AgentID.fromJSON(id, owner));
+        Object.assign(this, parsed);
+      } catch (e) {
+        throw new Error('Invalid JSON string: ' + e.message);
+      }
+    }  }
 
   /**
-   * Returns true if the agent id represents a topic.
-   *
-   * @returns {boolean} - true if the agent id represents a topic, false if it represents an agent
-   */
-  isTopic() {
-    return this.topic;
+  * Creates a JSONMessage object to send a message.
+  *
+  * @param {Message} msg
+  * @param {boolean} [relay=false] - whether to relay the message
+  * @returns {JSONMessage} - JSONMessage object with request to send a message
+  */
+  static createSend(msg, relay=false){
+    if (!(msg instanceof Message)) {
+      throw new Error('Invalid message type');
+    }
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.SEND;
+    jsonMsg.relay = relay;
+    jsonMsg.message = msg;
+    return jsonMsg;
   }
 
   /**
-   * Sends a message to the agent represented by this id.
-   *
-   * @param {Message} msg - message to send
-   * @returns {void}
-   */
-  send(msg) {
-    msg.recipient = this.toJSON();
-    if (this.owner) this.owner.send(msg);
-    else throw new Error('Unowned AgentID cannot send messages');
+  * Creates a JSONMessage object to update WantsMessagesFor list.
+  *
+  * @param {Array<AgentID>} agentIDs - array of AgentID objects for which the gateway wants messages
+  * @returns {JSONMessage} - JSONMessage object with request to update WantsMessagesFor list
+  */
+  static createWantsMessagesFor(agentIDs) {
+    if (!Array.isArray(agentIDs) || agentIDs.length === 0) {
+      throw new Error('agentIDNames must be a non-empty array');
+    }
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.WANTS_MESSAGES_FOR;
+    jsonMsg.agentIDs = agentIDs;
+    return jsonMsg;
   }
 
   /**
-   * Sends a request to the agent represented by this id and waits for a reponse.
-   *
-   * @param {Message} msg - request to send
-   * @param {number} [timeout=1000] - timeout in milliseconds
-   * @returns {Promise<Message>} - response
-   */
-  async request(msg, timeout=1000) {
-    msg.recipient = this.toJSON();
-    if (this.owner) return this.owner.request(msg, timeout);
-    else throw new Error('Unowned AgentID cannot send messages');
+  * Creates a JSONMessage object to request the list of agents.
+  *
+  * @returns {JSONMessage} - JSONMessage object with request for the list of agents
+  */
+  static createAgents(){
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.AGENTS;
+    jsonMsg.id = UUID7.generate().toString(); // unique JSON message ID
+    return jsonMsg;
   }
 
   /**
-   * Gets a string representation of the agent id.
-   *
-   * @returns {string} - string representation of the agent id
-   */
-  toString() {
-    return this.toJSON() + ((this.owner && this.owner.connector) ? ` on ${this.owner.connector.url}` : '');
+  * Creates a JSONMessage object to check if an agent is contained
+  *
+  * @param {AgentID} agentID - AgentID of the agent to check
+  * @returns {JSONMessage} - JSONMessage object with request to check if the agent is contained
+  */
+  static createContainsAgent(agentID) {
+    if (!(agentID instanceof AgentID)) {
+      throw new Error('agentID must be an instance of AgentID');
+    }
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.CONTAINS_AGENT;
+    jsonMsg.id = UUID7.generate().toString(); // unique JSON message ID
+    jsonMsg.agentID = agentID;
+    return jsonMsg;
   }
 
   /**
-   * Gets a JSON string representation of the agent id.
-   *
-   * @returns {string} - JSON string representation of the agent id
-   */
-  toJSON() {
-    return (this.topic ? '#' : '') + this.name;
+  * Creates a JSONMessage object to get an agent for a service.
+  *
+  * @param {string} service - service which the agent must provide
+  * @returns {JSONMessage} - JSONMessage object with request for an agent providing the service
+  */
+  static createAgentForService(service) {
+    if (typeof service !== 'string' || service.length === 0) {
+      throw new Error('service must be a non-empty string');
+    }
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.AGENT_FOR_SERVICE;
+    jsonMsg.id = UUID7.generate().toString(); // unique JSON message ID
+    jsonMsg.service = service;
+    return jsonMsg;
   }
 
   /**
-   * Sets parameter(s) on the Agent referred to by this AgentID.
-   *
-   * @param {(string|string[])} params - parameters name(s) to be set
-   * @param {(Object|Object[])} values - parameters value(s) to be set
-   * @param {number} [index=-1] - index of parameter(s) to be set
-   * @param {number} [timeout=5000] - timeout for the response
-   * @returns {Promise<(Object|Object[])>} - a promise which returns the new value(s) of the parameters
-   */
-  async set (params, values, index=-1, timeout=5000) {
-    if (!params) return null;
-    let msg = new ParameterReq();
-    msg.recipient = this.name;
-    if (Array.isArray(params)){
-      msg.param = params.shift();
-      msg.value = values.shift();
-      msg.requests = params.map((p, i) => {
-        return {
-          'param': p,
-          'value': values[i]
-        };
-      });
-      // Add back for generating a response
-      params.unshift(msg.param);
-    } else {
-      msg.param = params;
-      msg.value = values;
-    }
-    msg.index = Number.isInteger(index) ? index : -1;
-    const rsp = await this.owner.request(msg, timeout);
-    var ret = Array.isArray(params) ? new Array(params.length).fill(null) : null;
-    if (!rsp || rsp.perf != Performative.INFORM || !rsp.param) {
-      if (this.owner._returnNullOnFailedResponse) return ret;
-      else throw new Error(`Unable to set ${this.name}.${params} to ${values}`);
-    }
-    if (Array.isArray(params)) {
-      if (!rsp.values) rsp.values = {};
-      if (rsp.param) rsp.values[rsp.param] = rsp.value;
-      const rkeys = Object.keys(rsp.values);
-      return params.map( p => {
-        if (p.includes('.')) p = p.split('.').pop();
-        let f = rkeys.find(k => (k.includes('.') ? k.split('.').pop() : k) == p);
-        return f ? rsp.values[f] : undefined;
-      });
-    } else {
-      return rsp.value;
+  * Creates a JSONMessage object to get all agents for a service.
+  *
+  * @param {string} service - service which the agents must provide
+  * @returns {JSONMessage} - JSONMessage object with request for all agent providing the service
+  */
+  static createAgentsForService(service) {
+    if (typeof service !== 'string' || service.length === 0) {
+      throw new Error('service must be a non-empty string');
     }
+    const jsonMsg = new JSONMessage();
+    jsonMsg.action = Actions.AGENTS_FOR_SERVICE;
+    jsonMsg.id = UUID7.generate().toString(); // unique JSON message ID
+    jsonMsg.service = service;
+    return jsonMsg;
   }
 
-
   /**
-   * Gets parameter(s) on the Agent referred to by this AgentID.
-   *
-   * @param {(?string|?string[])} params - parameters name(s) to be get, null implies get value of all parameters on the Agent
-   * @param {number} [index=-1] - index of parameter(s) to be get
-   * @param {number} [timeout=5000] - timeout for the response
-   * @returns {Promise<(?Object|?Object[])>} - a promise which returns the value(s) of the parameters
-   */
-  async get(params, index=-1, timeout=5000) {
-    let msg = new ParameterReq();
-    msg.recipient = this.name;
-    if (params){
-      if (Array.isArray(params)) {
-        msg.param = params.shift();
-        msg.requests = params.map(p => {return {'param': p};});
-        // Add back for generating a response
-        params.unshift(msg.param);
-      }
-      else msg.param = params;
+  * Converts the JSONMessage object to a JSON string in the format of the
+  * fjage on-the-wire protocol. If the JSONMessage contains a Message or
+  * AgentID objects, they will be serialized as per the fjåge protocol.
+  *
+  * @returns {string} - JSON string representation of the message
+  */
+  toJSON() {
+    if (!this.action && !this.id) {
+      throw new Error('Neither action nor id is set. Cannot serialize JSONMessage.');
     }
-    msg.index = Number.isInteger(index) ? index : -1;
-    const rsp = await this.owner.request(msg, timeout);
-    var ret = Array.isArray(params) ? new Array(params.length).fill(null) : null;
-    if (!rsp || rsp.perf != Performative.INFORM || !rsp.param) {
-      if (this.owner._returnNullOnFailedResponse) return ret;
-      else throw new Error(`Unable to get ${this.name}.${params}`);
+    const jsonObj = {};
+    // Add property if not null or undefined
+    if (this.id) jsonObj.id = this.id;
+    if (this.action) jsonObj.action = this.action;
+    if (this.inResponseTo) jsonObj.inResponseTo = this.inResponseTo;
+    if (this.agentID) jsonObj.agentID = this.agentID.toJSON();
+    if (this.agentIDs) {
+      jsonObj.agentIDs = this.agentIDs.map(id => id.toJSON());
+      if (jsonObj.agentIDs.length === 0) delete jsonObj.agentIDs; // remove empty array
     }
-    // Request for listing of all parameters.
-    if (!params) {
-      if (!rsp.values) rsp.values = {};
-      if (rsp.param) rsp.values[rsp.param] = rsp.value;
-      return rsp.values;
-    } else if (Array.isArray(params)) {
-      if (!rsp.values) rsp.values = {};
-      if (rsp.param) rsp.values[rsp.param] = rsp.value;
-      const rkeys = Object.keys(rsp.values);
-      return params.map( p => {
-        if (p.includes('.')) p = p.split('.').pop();
-        let f = rkeys.find(k => (k.includes('.') ? k.split('.').pop() : k) == p);
-        return f ? rsp.values[f] : undefined;
-      });
-    } else {
-      return rsp.value;
+    if (this.service) jsonObj.service = this.service;
+    if (this.services) {
+      jsonObj.services = this.services;
+      if (jsonObj.services.length === 0) delete jsonObj.services; // remove empty array
     }
+    if (this.answer != undefined) jsonObj.answer = this.answer;
+    if (this.message) jsonObj.message = this.message;
+    if (this.relay) jsonObj.relay = this.relay;
+    if (this.creds) jsonObj.creds = this.creds;
+    if (this.auth) jsonObj.auth = this.auth;
+    if (this.name) jsonObj.name = this.name;
+    return JSON.stringify(jsonObj);
+  }
+
+  toString() {
+    return this.toJSON();
   }
 }
 
-// protected String msgID = UUID.randomUUID().toString();
-// protected Performative perf;
-// protected AgentID recipient;
-// protected AgentID sender = null;
-// protected String inReplyTo = null;
-// protected Long sentAt = null;
 
 /**
- * Base class for messages transmitted by one agent to another. Creates an empty message.
- * @class
- * @param {string} [msgID] - unique identifier for the message
- * @param {Performative} [perf=Performative.INFORM] - performative
- * @param {AgentID} [recipient] - recipient of the message
- * @param {AgentID} [sender] - sender of the message
- * @param {string} [inReplyTo] - message to which this response corresponds to
- * @param {Message} [inReplyTo] - message to which this response corresponds to
- * @param {number} [sentAt] - time at which the message was sent
- */
-class Message {
+* Actions supported by the fjåge JSON message protocol. See
+* {@link https://fjage.readthedocs.io/en/latest/protocol.html#json-message-request-response-attributes fjage documentation} for more details.
+*
+* @enum {string} Actions
+*/
+const Actions = {
+  AGENTS : 'agents',
+  CONTAINS_AGENT : 'containsAgent',
+  AGENT_FOR_SERVICE : 'agentForService',
+  AGENTS_FOR_SERVICE : 'agentsForService',
+  SEND : 'send',
+  WANTS_MESSAGES_FOR : 'wantsMessagesFor'};
 
-  constructor(inReplyTo={msgID:null, sender:null}, perf=Performative.INFORM) {
-    this.__clazz__ = 'org.arl.fjage.Message';
-    this.msgID = _guid(8);
-    this.sender = null;
-    this.recipient = inReplyTo.sender;
-    this.perf = perf;
-    this.inReplyTo = inReplyTo.msgID || null;
-  }
+////// private utilities
 
-  /**
-   * Gets a string representation of the message.
-   *
-   * @returns {string} - string representation
-   */
-  toString() {
-    let s = '';
-    let suffix = '';
-    if (!this.__clazz__) return '';
-    let clazz = this.__clazz__;
-    clazz = clazz.replace(/^.*\./, '');
-    let perf = this.perf;
-    for (var k in this) {
-      if (k.startsWith('__')) continue;
-      if (k == 'sender') continue;
-      if (k == 'recipient') continue;
-      if (k == 'msgID') continue;
-      if (k == 'perf') continue;
-      if (k == 'inReplyTo') continue;
-      if (typeof this[k] == 'object') {
-        suffix = ' ...';
-        continue;
-      }
-      s += ' ' + k + ':' + this[k];
-    }
-    s += suffix;
-    return clazz+':'+perf+'['+s.replace(/^ /, '')+']';
-  }
 
-  // convert a message into a JSON string
-  // NOTE: we don't do any base64 encoding for TX as
-  //       we don't know what data type is intended
-  /**
-   * @private
-   *
-   * @return {string} - JSON string representation of the message
-   */
-  _serialize() {
-    let clazz = this.__clazz__ || 'org.arl.fjage.Message';
-    let data = JSON.stringify(this, (k,v) => {
-      if (k.startsWith('__')) return;
-      return v;
-    });
-    return '{ "clazz": "'+clazz+'", "data": '+data+' }';
+/**
+* Decode large numeric arrays encoded in base64 back to array format.
+*
+* @private
+*
+* @param {string} _k - key (unused)
+* @param {any} d - data
+* @returns {Array} - decoded data in array format
+* */
+function _decodeBase64(_k, d) {
+  if (d === null) return null;
+  if (typeof d == 'object' && 'clazz' in d && 'data' in d && d.clazz.startsWith('[') && d.clazz.length == 2) {
+    return _b64toArray(d.data, d.clazz) || d;
   }
+  return d;
+}
 
-  // inflate a data dictionary into the message
-  /** @private */
-  _inflate(data) {
-    for (var key in data)
-      this[key] = data[key];
+/**
+* Convert a base64 encoded string to an array of numbers of the specified data type.
+*
+* @private
+*
+* @param {string} base64 - base64 encoded string
+* @param {string} dtype - data type, e.g. '[B' for byte array, '[S' for short array, etc.
+* @param {boolean} [littleEndian=true] - whether to use little-endian byte order
+*/
+function _b64toArray(base64, dtype, littleEndian=true) {
+  let s = _atob(base64);
+  let len = s.length;
+  let bytes = new Uint8Array(len);
+  for (var i = 0; i < len; i++)
+    bytes[i] = s.charCodeAt(i);
+  let rv = [];
+  let view = new DataView(bytes.buffer);
+  switch (dtype) {
+    case '[B': // byte array
+    for (i = 0; i < len; i++)
+      rv.push(view.getUint8(i));
+    break;
+    case '[S': // short array
+    for (i = 0; i < len; i+=2)
+      rv.push(view.getInt16(i, littleEndian));
+    break;
+    case '[I': // integer array
+    for (i = 0; i < len; i+=4)
+      rv.push(view.getInt32(i, littleEndian));
+    break;
+    case '[J': // long array
+    for (i = 0; i < len; i+=8)
+      rv.push(view.getBigInt64(i, littleEndian));
+    break;
+    case '[F': // float array
+    for (i = 0; i < len; i+=4)
+      rv.push(view.getFloat32(i, littleEndian));
+    break;
+    case '[D': // double array
+    for (i = 0; i < len; i+=8)
+      rv.push(view.getFloat64(i, littleEndian));
+    break;
+    default:
+    return;
   }
+  return rv;
+}
 
-  // convert a dictionary (usually from decoding JSON) into a message
-  /**
-   * @private
-   *
-   * @param {(string|Object)} json - JSON string or object to be converted to a message
-   * @returns {Message} - message created from the JSON string or object
-   * */
-  static _deserialize(json) {
-    let obj = null;
-    if (typeof json == 'string') {
-      try {
-        obj = JSON.parse(json);
-      }catch(e){
-        return null;
-      }
-    } else obj = json;
-    let qclazz = obj.clazz;
-    let clazz = qclazz.replace(/^.*\./, '');
-    let rv = MessageClass[clazz] ? new MessageClass[clazz] : new Message();
-    rv.__clazz__ = qclazz;
-    rv._inflate(obj.data);
-    return rv;
+// node.js safe atob function
+/**
+* @private
+* @param {string} a
+*/
+function _atob(a){
+  if (isBrowser || isWebWorker) return window.atob(a);
+  else if (isJsDom || isNode) return Buffer.from(a, 'base64').toString('binary');
+}
+
+/* global global */
+
+
+const DEFAULT_QUEUE_SIZE = 128;        // max number of old unreceived messages to store
+const DEFAULT_TIMEOUT$1 = 10000;         // default timeout for requests in milliseconds
+
+const GATEWAY_DEFAULTS = {
+  'timeout': DEFAULT_TIMEOUT$1,
+  'keepAlive' : true,
+  'queueSize': DEFAULT_QUEUE_SIZE,
+  'returnNullOnFailedResponse': true
+};
+
+let DEFAULT_URL;
+let gObj = {};
+
+/**
+*
+* @private
+*
+* Initializes the Gateway module. This function should be called before using the Gateway class.
+* It sets up the default values for the Gateway and initializes the global object.
+* It also sets up the default URL for the Gateway based on the environment (browser, Node.js, etc.).
+* @returns {void}
+*/
+function init(){
+  if (isBrowser || isWebWorker){
+    gObj = window;
+    Object.assign(GATEWAY_DEFAULTS, {
+      'hostname': gObj.location.hostname,
+      'port': gObj.location.port,
+      'pathname' : '/ws/'
+    });
+    DEFAULT_URL = new URL('ws://localhost');
+    // Enable caching of Gateways in browser
+    if (typeof gObj.fjage === 'undefined') gObj.fjage = {};
+    if (typeof gObj.fjage.gateways == 'undefined') gObj.fjage.gateways = [];
+  } else if (isJsDom || isNode){
+    gObj = global;
+    Object.assign(GATEWAY_DEFAULTS, {
+      'hostname': 'localhost',
+      'port': '1100',
+      'pathname': ''
+    });
+    DEFAULT_URL = new URL('tcp://localhost');
   }
 }
 
 /**
- * A gateway for connecting to a fjage master container. The new version of the constructor
- * uses an options object instead of individual parameters. The old version with
- *
- *
- * @class
- * @param {Object} opts
- * @param {string} [opts.hostname="localhost"] - hostname/ip address of the master container to connect to
- * @param {number} [opts.port=1100]          - port number of the master container to connect to
- * @param {string} [opts.pathname=""]        - path of the master container to connect to (for WebSockets)
- * @param {string} [opts.keepAlive=true]     - try to reconnect if the connection is lost
- * @param {number} [opts.queueSize=128]      - size of the queue of received messages that haven't been consumed yet
- * @param {number} [opts.timeout=1000]       - timeout for fjage level messages in ms
- * @param {boolean} [opts.returnNullOnFailedResponse=true] - return null instead of throwing an error when a parameter is not found
- * @param {boolean} [opts.cancelPendingOnDisconnect=false] - cancel pending requests on disconnect
- */
+* A gateway for connecting to a fjage master container. This class provides methods to
+* send and receive messages, subscribe to topics, and manage connections to the master container.
+* It can be used to connect to a fjage master container over WebSockets or TCP.
+*
+* @example <caption>Connects to the localhost:1100</caption>
+* const gw = new Gateway({ hostname: 'localhost', port: 1100 });
+*
+* @example <caption>Connects to the origin</caption>
+* const gw = new Gateway();
+*
+* @class
+* @property {AgentID} aid - agent id of the gateway
+* @property {boolean} connected - true if the gateway is connected to the master container
+* @property {boolean} debug - true if debug messages should be logged to the console
+*
+* Constructor arguments:
+* @param {Object} opts
+* @param {string} [opts.hostname="localhost"] - hostname/ip address of the master container to connect to
+* @param {number} [opts.port=1100]          - port number of the master container to connect to
+* @param {string} [opts.pathname=""]        - path of the master container to connect to (for WebSockets)
+* @param {boolean} [opts.keepAlive=true]     - try to reconnect if the connection is lost
+* @param {number} [opts.queueSize=128]      - size of the _queue of received messages that haven't been consumed yet
+* @param {number} [opts.timeout=10000]       - timeout for fjage level messages in ms
+* @param {boolean} [opts.returnNullOnFailedResponse=true] - return null instead of throwing an error when a parameter is not found
+* @param {boolean} [opts.cancelPendingOnDisconnect=false] - cancel pending requests on disconnects
+*/
 class Gateway {
 
   constructor(opts = {}) {
@@ -709,14 +899,14 @@ class Gateway {
     if (existing) return existing;
     this._timeout = opts.timeout;         // timeout for fjage level messages (agentForService etc)
     this._keepAlive = opts.keepAlive;     // reconnect if connection gets closed/errored
-    this._queueSize = opts.queueSize;     // size of queue
+    this._queueSize = opts.queueSize;     // size of _queue
     this._returnNullOnFailedResponse = opts.returnNullOnFailedResponse; // null or error
     this._cancelPendingOnDisconnect = opts.cancelPendingOnDisconnect; // cancel pending requests on disconnect
-    this.pending = {};                    // msgid to callback mapping for pending requests to server
-    this.subscriptions = {};              // hashset for all topics that are subscribed
-    this.listeners = {};                  // list of callbacks that want to listen to incoming messages
-    this.eventListeners = {};             // external listeners wanting to listen internal events
-    this.queue = [];                      // incoming message queue
+    this._pending_actions = {};            // msgid to callback mapping for pending actions
+    this._subscriptions = {};              // map for all topics that are subscribed
+    this._pending_receives = {};           // uuid to callbacks mapping for pending receives
+    this._eventListeners = {};             // external listeners wanting to listen internal events
+    this._queue = [];                      // incoming message _queue
     this.connected = false;               // connection status
     this.debug = false;                   // debug info to be logged to console?
     this.aid = new AgentID('gateway-'+_guid(4));         // gateway agent name
@@ -725,14 +915,14 @@ class Gateway {
   }
 
   /**
-   * Sends an event to all registered listeners of the given type.
-   * @private
-   * @param {string} type - type of event
-   * @param {Object|Message|string} val - value to be sent to the listeners
-   */
+  * Sends an event to all registered listeners of the given type.
+  * @private
+  * @param {string} type - type of event
+  * @param {Object|Message|string} val - value to be sent to the listeners
+  */
   _sendEvent(type, val) {
-    if (!Array.isArray(this.eventListeners[type])) return;
-    this.eventListeners[type].forEach(l => {
+    if (!Array.isArray(this._eventListeners[type])) return;
+    this._eventListeners[type].forEach(l => {
       if (l && {}.toString.call(l) === '[object Function]'){
         try {
           l(val);
@@ -744,16 +934,16 @@ class Gateway {
   }
 
   /**
-   * Sends the message to all registered receivers.
-   *
-   * @private
-   * @param {Message} msg
-   * @returns {boolean} - true if the message was consumed by any listener
-   */
+  * Sends the message to all registered receivers.
+  *
+  * @private
+  * @param {Message} msg
+  * @returns {boolean} - true if the message was consumed by any listener
+  */
   _sendReceivers(msg) {
-    for (var lid in this.listeners){
+    for (var lid in this._pending_receives){
       try {
-        if (this.listeners[lid] && this.listeners[lid](msg)) return true;
+        if (this._pending_receives[lid] && this._pending_receives[lid](msg)) return true;
       } catch (error) {
         console.warn('Error in listener : ' + error);
       }
@@ -763,59 +953,60 @@ class Gateway {
 
 
   /**
-   * @private
-   * @param {string} data - stringfied JSON data received from the master container to be processed
-   * @returns {void}
-   */
+  * @private
+  * @param {string} data - stringfied JSON data received from the master container to be processed
+  * @returns {void}
+  */
   _onMsgRx(data) {
-    var obj;
+    var jsonMsg;
     if (this.debug) console.log('< '+data);
     this._sendEvent('rx', data);
     try {
-      obj = JSON.parse(data, _decodeBase64);
+      jsonMsg = new JSONMessage(data, this);
     }catch(e){
       return;
     }
-    this._sendEvent('rxp', obj);
-    if ('id' in obj && obj.id in this.pending) {
+    this._sendEvent('rxp', jsonMsg);
+    if (jsonMsg.id && jsonMsg.id in this._pending_actions) {
       // response to a pending request to master
-      this.pending[obj.id](obj);
-      delete this.pending[obj.id];
-    } else if (obj.action == 'send') {
+      this._pending_actions[jsonMsg.id](jsonMsg);
+      delete this._pending_actions[jsonMsg.id];
+    } else if (jsonMsg.action == Actions.SEND) {
       // incoming message from master
-      // @ts-ignore
-      let msg = Message._deserialize(obj.message);
+      const msg = jsonMsg.message;
       if (!msg) return;
       this._sendEvent('rxmsg', msg);
-      if ((msg.recipient == this.aid.toJSON() )|| this.subscriptions[msg.recipient]) {
+      if ((msg.recipient.toJSON() == this.aid.toJSON())|| this._subscriptions[msg.recipient.toJSON()]) {
         // send to any "message" listeners
         this._sendEvent('message', msg);
-        // send message to receivers, if not consumed, add to queue
+        // send message to receivers, if not consumed, add to _queue
         if(!this._sendReceivers(msg)) {
-          if (this.queue.length >= this._queueSize) this.queue.shift();
-          this.queue.push(msg);
+          if (this._queue.length >= this._queueSize) this._queue.shift();
+          this._queue.push(msg);
         }
       }
     } else {
-      // respond to standard requests that every container must
-      let rsp = { id: obj.id, inResponseTo: obj.action };
-      switch (obj.action) {
-      case 'agents':
-        rsp.agentIDs = [this.aid.getName()];
+      // respond to standard requests that every gateway must
+      let rsp = new JSONMessage();
+      rsp.id = jsonMsg.id;
+      rsp.inResponseTo = jsonMsg.action;
+      switch (jsonMsg.action) {
+        case 'agents':
+        rsp.agentIDs = [this.aid];
         break;
-      case 'containsAgent':
-        rsp.answer = (obj.agentID == this.aid.getName());
+        case 'containsAgent':
+        rsp.answer = (jsonMsg.agentID.toJSON() == this.aid.toJSON());
         break;
-      case 'services':
+        case 'services':
         rsp.services = [];
         break;
-      case 'agentForService':
+        case 'agentForService':
         rsp.agentID = '';
         break;
-      case 'agentsForService':
+        case 'agentsForService':
         rsp.agentIDs = [];
         break;
-      default:
+        default:
         rsp = undefined;
       }
       if (rsp) this._msgTx(rsp);
@@ -823,49 +1014,56 @@ class Gateway {
   }
 
   /**
-   * Sends a message out to the master container.
-   * @private
-   * @param {string|Object} s - JSON object (either stringified or not) to be sent to the master container
-   * @returns {boolean} - true if the message was sent successfully
-   */
-  _msgTx(s) {
-    if (typeof s != 'string' && !(s instanceof String)) s = JSON.stringify(s);
+  * Sends a message out to the master container. This method is used for sending
+  * fjage level actions that do not require a response, such as alive, wantMessages, etc.
+  * @private
+  * @param {JSONMessage} msg - JSONMessage to be sent to the master container
+  * @returns {boolean} - true if the message was sent successfully
+  */
+  _msgTx(msg) {
+    const s = msg.toJSON();
     if(this.debug) console.log('> '+s);
     this._sendEvent('tx', s);
     return this.connector.write(s);
   }
 
   /**
-   * @private
-   * @param {Object} rq - request to be sent to the master container as a JSON object
-   * @returns {Promise<Object>} - a promise which returns the response from the master container
-   */
-  _msgTxRx(rq) {
-    rq.id = _guid(8);
+  * Send a message to the master container and wait for a response. This method is used for sending
+  * fjage level actions that require a response, such as agentForService, agents, etc.
+  * @private
+  * @param {JSONMessage} rq - JSONMessage to be sent to the master container
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds for the response
+  * @returns {Promise<JSONMessage|null>} - a promise which returns the response from the master container
+  */
+  _msgTxRx(rq, timeout = this._timeout) {
+    rq.id = UUID7.generate().toString();
     return new Promise(resolve => {
-      let timer = setTimeout(() => {
-        delete this.pending[rq.id];
-        if (this.debug) console.log('Receive Timeout : ' + JSON.stringify(rq));
-        resolve();
-      }, 8*this._timeout);
-      this.pending[rq.id] = rsp => {
-        clearTimeout(timer);
+      let timer;
+      if (timeout >= 0){
+        timer = setTimeout(() => {
+          delete this._pending_actions[rq.id];
+          if (this.debug) console.log('Receive Timeout : ' + JSON.stringify(rq));
+          resolve(null);
+        }, timeout);
+      }
+      this._pending_actions[rq.id] = rsp => {
+        if (timer) clearTimeout(timer);
         resolve(rsp);
       };
       if (!this._msgTx.call(this,rq)) {
-        clearTimeout(timer);
-        delete this.pending[rq.id];
-        if (this.debug) console.log('Transmit Timeout : ' +  JSON.stringify(rq));
-        resolve();
+        if(timer) clearTimeout(timer);
+        delete this._pending_actions[rq.id];
+        if (this.debug) console.log('Transmit Failure : ' +  JSON.stringify(rq));
+        resolve(null);
       }
     });
   }
 
   /**
-   * @private
-   * @param {URL} url - URL object of the master container to connect to
-   * @returns {TCPConnector|WSConnector} - connector object to connect to the master container
-   */
+  * @private
+  * @param {URL} url - URL object of the master container to connect to
+  * @returns {TCPConnector|WSConnector} - connector object to connect to the master container
+  */
   _createConnector(url){
     let conn;
     if (url.protocol.startsWith('ws')){
@@ -903,12 +1101,12 @@ class Gateway {
   }
 
   /**
-   * Checks if the object is a constructor.
-   *
-   * @private
-   * @param {Object} value - an object to be checked if it is a constructor
-   * @returns {boolean} - if the object is a constructor
-   */
+  * Checks if the object is a constructor.
+  *
+  * @private
+  * @param {Object} value - an object to be checked if it is a constructor
+  * @returns {boolean} - if the object is a constructor
+  */
   _isConstructor(value) {
     try {
       new new Proxy(value, {construct() { return {}; }});
@@ -919,12 +1117,12 @@ class Gateway {
   }
 
   /**
-   * Matches a message with a filter.
-   * @private
-   * @param {string|Object|function} filter - filter to be matched
-   * @param {Message} msg - message to be matched to the filter
-   * @returns {boolean} - true if the message matches the filter
-   */
+  * Matches a message with a filter.
+  * @private
+  * @param {string|Object|function} filter - filter to be matched
+  * @param {Message} msg - message to be matched to the filter
+  * @returns {boolean} - true if the message matches the filter
+  */
   _matchMessage(filter, msg){
     if (typeof filter == 'string' || filter instanceof String) {
       return 'inReplyTo' in msg && msg.inReplyTo == filter;
@@ -945,24 +1143,24 @@ class Gateway {
   }
 
   /**
-   * Gets the next message from the queue that matches the filter.
-   * @private
-   * @param {string|Object|function} filter - filter to be matched
-   */
+  * Gets the next message from the _queue that matches the filter.
+  * @private
+  * @param {string|Object|function} filter - filter to be matched
+  */
   _getMessageFromQueue(filter) {
-    if (!this.queue.length) return;
-    if (!filter) return this.queue.shift();
-    let matchedMsg = this.queue.find( msg => this._matchMessage(filter, msg));
-    if (matchedMsg) this.queue.splice(this.queue.indexOf(matchedMsg), 1);
+    if (!this._queue.length) return;
+    if (!filter) return this._queue.shift();
+    let matchedMsg = this._queue.find( msg => this._matchMessage(filter, msg));
+    if (matchedMsg) this._queue.splice(this._queue.indexOf(matchedMsg), 1);
     return matchedMsg;
   }
 
   /**
-   * Gets a cached gateway object for the given URL (if it exists).
-   * @private
-   * @param {URL} url - URL object of the master container to connect to
-   * @returns {Gateway|void} - gateway object for the given URL
-   */
+  * Gets a cached gateway object for the given URL (if it exists).
+  * @private
+  * @param {URL} url - URL object of the master container to connect to
+  * @returns {Gateway|void} - gateway object for the given URL
+  */
   _getGWCache(url){
     if (!gObj.fjage || !gObj.fjage.gateways) return null;
     var f = gObj.fjage.gateways.filter(g => g.connector.url.toString() == url.toString());
@@ -971,20 +1169,20 @@ class Gateway {
   }
 
   /**
-   * Adds a gateway object to the cache if it doesn't already exist.
-   * @private
-   * @param {Gateway} gw - gateway object to be added to the cache
-   */
+  * Adds a gateway object to the cache if it doesn't already exist.
+  * @private
+  * @param {Gateway} gw - gateway object to be added to the cache
+  */
   _addGWCache(gw){
     if (!gObj.fjage || !gObj.fjage.gateways) return;
     gObj.fjage.gateways.push(gw);
   }
 
   /**
-   * Removes a gateway object from the cache if it exists.
-   * @private
-   * @param {Gateway} gw - gateway object to be removed from the cache
-   */
+  * Removes a gateway object from the cache if it exists.
+  * @private
+  * @param {Gateway} gw - gateway object to be removed from the cache
+  */
   _removeGWCache(gw){
     if (!gObj.fjage || !gObj.fjage.gateways) return;
     var index = gObj.fjage.gateways.indexOf(gw);
@@ -993,105 +1191,105 @@ class Gateway {
 
   /** @private */
   _update_watch() {
-    let watch = Object.keys(this.subscriptions);
-    watch.push(this.aid.getName());
-    let rq = { action: 'wantsMessagesFor', agentIDs: watch };
-    this._msgTx(rq);
+    let watch = Object.keys(this._subscriptions);
+    watch.push(this.aid.toJSON());
+    const jsonMsg = JSONMessage.createWantsMessagesFor(watch.map(id => AgentID.fromJSON(id)));
+    this._msgTx(jsonMsg);
   }
 
   /**
-   * Add an event listener to listen to various events happening on this Gateway
-   *
-   * @param {string} type - type of event to be listened to
-   * @param {function} listener - new callback/function to be called when the event happens
-   * @returns {void}
-   */
+  * Add an event listener to listen to various events happening on this Gateway
+  *
+  * @param {string} type - type of event to be listened to
+  * @param {function} listener - new callback/function to be called when the event happens
+  * @returns {void}
+  */
   addEventListener(type, listener) {
-    if (!Array.isArray(this.eventListeners[type])){
-      this.eventListeners[type] = [];
+    if (!Array.isArray(this._eventListeners[type])){
+      this._eventListeners[type] = [];
     }
-    this.eventListeners[type].push(listener);
+    this._eventListeners[type].push(listener);
   }
 
   /**
-   * Remove an event listener.
-   *
-   * @param {string} type - type of event the listener was for
-   * @param {function} listener - callback/function which was to be called when the event happens
-   * @returns {void}
-   */
+  * Remove an event listener.
+  *
+  * @param {string} type - type of event the listener was for
+  * @param {function} listener - callback/function which was to be called when the event happens
+  * @returns {void}
+  */
   removeEventListener(type, listener) {
-    if (!this.eventListeners[type]) return;
-    let ndx = this.eventListeners[type].indexOf(listener);
-    if (ndx >= 0) this.eventListeners[type].splice(ndx, 1);
+    if (!this._eventListeners[type]) return;
+    let ndx = this._eventListeners[type].indexOf(listener);
+    if (ndx >= 0) this._eventListeners[type].splice(ndx, 1);
   }
 
   /**
-   * Add a new listener to listen to all {Message}s sent to this Gateway
-   *
-   * @param {function} listener - new callback/function to be called when a {Message} is received
-   * @returns {void}
-   */
+  * Add a new listener to listen to all {Message}s sent to this Gateway
+  *
+  * @param {function} listener - new callback/function to be called when a {Message} is received
+  * @returns {void}
+  */
   addMessageListener(listener) {
     this.addEventListener('message',listener);
   }
 
   /**
-   * Remove a message listener.
-   *
-   * @param {function} listener - removes a previously registered listener/callback
-   * @returns {void}
-   */
+  * Remove a message listener.
+  *
+  * @param {function} listener - removes a previously registered listener/callback
+  * @returns {void}
+  */
   removeMessageListener(listener) {
     this.removeEventListener('message', listener);
   }
 
   /**
-   * Add a new listener to get notified when the connection to master is created and terminated.
-   *
-   * @param {function} listener - new callback/function to be called connection to master is created and terminated
-   * @returns {void}
-   */
+  * Add a new listener to get notified when the connection to master is created and terminated.
+  *
+  * @param {function} listener - new callback/function to be called connection to master is created and terminated
+  * @returns {void}
+  */
   addConnListener(listener) {
     this.addEventListener('conn', listener);
   }
 
   /**
-   * Remove a connection listener.
-   *
-   * @param {function} listener - removes a previously registered listener/callback
-   * @returns {void}
-   */
+  * Remove a connection listener.
+  *
+  * @param {function} listener - removes a previously registered listener/callback
+  * @returns {void}
+  */
   removeConnListener(listener) {
     this.removeEventListener('conn', listener);
   }
 
   /**
-   * Gets the agent ID associated with the gateway.
-   *
-   * @returns {AgentID} - agent ID
-   */
+  * Gets the agent ID associated with the gateway.
+  *
+  * @returns {AgentID} - agent ID
+  */
   getAgentID() {
     return this.aid;
   }
 
   /**
-   * Get an AgentID for a given agent name.
-   *
-   * @param {string} name - name of agent
-   * @returns {AgentID} - AgentID for the given name
-   */
+  * Get an AgentID for a given agent name.
+  *
+  * @param {string} name - name of agent
+  * @returns {AgentID} - AgentID for the given name
+  */
   agent(name) {
     return new AgentID(name, false, this);
   }
 
   /**
-   * Returns an object representing the named topic.
-   *
-   * @param {string|AgentID} topic - name of the topic or AgentID
-   * @param {string} [topic2] - name of the topic if the topic param is an AgentID
-   * @returns {AgentID} - object representing the topic
-   */
+  * Returns an object representing the named topic.
+  *
+  * @param {string|AgentID} topic - name of the topic or AgentID
+  * @param {string} [topic2] - name of the topic if the topic param is an AgentID
+  * @returns {AgentID} - object representing the topic
+  */
   topic(topic, topic2) {
     if (typeof topic == 'string' || topic instanceof String) return new AgentID(topic, true, this);
     if (topic instanceof AgentID) {
@@ -1101,143 +1299,139 @@ class Gateway {
   }
 
   /**
-   * Subscribes the gateway to receive all messages sent to the given topic.
-   *
-   * @param {AgentID} topic - the topic to subscribe to
-   * @returns {boolean} - true if the subscription is successful, false otherwise
-   */
+  * Subscribes the gateway to receive all messages sent to the given topic.
+  *
+  * @param {AgentID} topic - the topic to subscribe to
+  * @returns {boolean} - true if the subscription is successful, false otherwise
+  */
   subscribe(topic) {
     if (!topic.isTopic()) topic = new AgentID(topic.getName() + '__ntf', true, this);
-    this.subscriptions[topic.toJSON()] = true;
+    this._subscriptions[topic.toJSON()] = true;
     this._update_watch();
     return true;
   }
 
   /**
-   * Unsubscribes the gateway from a given topic.
-   *
-   * @param {AgentID} topic - the topic to unsubscribe
-   * @returns {void}
-   */
+  * Unsubscribes the gateway from a given topic.
+  *
+  * @param {AgentID} topic - the topic to unsubscribe
+  * @returns {void}
+  */
   unsubscribe(topic) {
     if (!topic.isTopic()) topic = new AgentID(topic.getName() + '__ntf', true, this);
-    delete this.subscriptions[topic.toJSON()];
+    delete this._subscriptions[topic.toJSON()];
     this._update_watch();
   }
 
   /**
-   * Gets a list of all agents in the container.
-   * @returns {Promise<AgentID[]>} - a promise which returns an array of all agent ids when resolved
-   */
-  async agents() {
-    let rq = { action: 'agents' };
-    let rsp = await this._msgTxRx(rq);
+  * Gets a list of all agents in the container.
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds
+  * @returns {Promise<AgentID[]>} - a promise which returns an array of all agent ids when resolved
+  */
+  async agents(timeout=this._timeout) {
+    let jsonMsg = JSONMessage.createAgents();
+    let rsp = await this._msgTxRx(jsonMsg, timeout);
     if (!rsp || !Array.isArray(rsp.agentIDs)) throw new Error('Unable to get agents');
-    return rsp.agentIDs.map(aid => new AgentID(aid, false, this));
+    return rsp.agentIDs;
   }
 
   /**
-   * Check if an agent with a given name exists in the container.
-   *
-   * @param {AgentID|String} agentID - the agent id to check
-   * @returns {Promise<boolean>} - a promise which returns true if the agent exists when resolved
-   */
-  async containsAgent(agentID) {
-    let rq = { action: 'containsAgent', agentID: agentID instanceof AgentID ? agentID.getName() : agentID };
-    let rsp = await this._msgTxRx(rq);
-    if (!rsp) throw new Error('Unable to check if agent exists');
+  * Check if an agent with a given name exists in the container.
+  *
+  * @param {AgentID|string} agentID - the agent id to check
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds
+  * @returns {Promise<boolean>} - a promise which returns true if the agent exists when resolved
+  */
+  async containsAgent(agentID, timeout=this._timeout) {
+    let jsonMsg = JSONMessage.createContainsAgent(agentID instanceof AgentID ? agentID : new AgentID(agentID));
+    let rsp = await this._msgTxRx(jsonMsg, timeout);
+    if (!rsp) {
+      if (this._returnNullOnFailedResponse) return null;
+      else throw new Error('Unable to check if agent exists');
+    }
     return !!rsp.answer;
   }
 
   /**
-   * Finds an agent that provides a named service. If multiple agents are registered
-   * to provide a given service, any of the agents' id may be returned.
-   *
-   * @param {string} service - the named service of interest
-   * @returns {Promise<?AgentID>} - a promise which returns an agent id for an agent that provides the service when resolved
-   */
-  async agentForService(service) {
-    let rq = { action: 'agentForService', service: service };
-    let rsp = await this._msgTxRx(rq);
+  * Finds an agent that provides a named service. If multiple agents are registered
+  * to provide a given service, any of the agents' id may be returned.
+  *
+  * @param {string} service - the named service of interest
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds
+  * @returns {Promise<?AgentID>} - a promise which returns an agent id for an agent that provides the service when resolved
+  */
+  async agentForService(service, timeout=this._timeout) {
+    let jsonMsg = JSONMessage.createAgentForService(service);
+    let rsp = await this._msgTxRx(jsonMsg, timeout);
     if (!rsp) {
       if (this._returnNullOnFailedResponse) return null;
       else throw new Error('Unable to get agent for service');
     }
-    if (!rsp.agentID) return null;
-    return new AgentID(rsp.agentID, false, this);
+    return rsp.agentID;
   }
-
-  /**
-   * Finds all agents that provides a named service.
-   *
-   * @param {string} service - the named service of interest
-   * @returns {Promise<?AgentID[]>} - a promise which returns an array of all agent ids that provides the service when resolved
-   */
-  async agentsForService(service) {
-    let rq = { action: 'agentsForService', service: service };
-    let rsp = await this._msgTxRx(rq);
-    let aids = [];
+
+  /**
+  * Finds all agents that provides a named service.
+  *
+  * @param {string} service - the named service of interest
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds
+  * @returns {Promise<AgentID[]>} - a promise which returns an array of all agent ids that provides the service when resolved
+  */
+  async agentsForService(service, timeout=this._timeout) {
+    let jsonMsg = JSONMessage.createAgentsForService(service);
+    let rsp = await this._msgTxRx(jsonMsg, timeout);
     if (!rsp) {
-      if (this._returnNullOnFailedResponse) return aids;
+      if (this._returnNullOnFailedResponse) return null;
       else throw new Error('Unable to get agents for service');
     }
-    if (!Array.isArray(rsp.agentIDs)) return aids;
-    for (var i = 0; i < rsp.agentIDs.length; i++)
-      aids.push(new AgentID(rsp.agentIDs[i], false, this));
-    return aids;
+    return rsp.agentIDs || [];
   }
 
   /**
-   * Sends a message to the recipient indicated in the message. The recipient
-   * may be an agent or a topic.
-   *
-   * @param {Message} msg - message to be sent
-   * @returns {boolean} - if sending was successful
-   */
+  * Sends a message to the recipient indicated in the message. The recipient
+  * may be an agent or a topic.
+  *
+  * @param {Message} msg - message to be sent
+  * @returns {boolean} - if sending was successful
+  */
   send(msg) {
-    msg.sender = this.aid.toJSON();
-    if (msg.perf == '') {
-      if (msg.__clazz__.endsWith('Req')) msg.perf = Performative.REQUEST;
-      else msg.perf = Performative.INFORM;
-    }
+    msg.sender = this.aid;
     this._sendEvent('txmsg', msg);
-    let rq = JSON.stringify({ action: 'send', relay: true, message: '###MSG###' });
-    // @ts-ignore
-    rq = rq.replace('"###MSG###"', msg._serialize());
-    return !!this._msgTx(rq);
+    const jsonMsg = JSONMessage.createSend(msg, true);
+    return !!this._msgTx(jsonMsg);
   }
 
   /**
-   * Flush the Gateway queue for all pending messages. This drops all the pending messages.
-   * @returns {void}
-   *
-   */
+  * Flush the Gateway _queue for all pending messages. This drops all the pending messages.
+  * @returns {void}
+  *
+  */
   flush() {
-    this.queue.length = 0;
+    this._queue.length = 0;
   }
 
   /**
-   * Sends a request and waits for a response. This method returns a {Promise} which resolves when a response
-   * is received or if no response is received after the timeout.
-   *
-   * @param {Message} msg - message to send
-   * @param {number} [timeout=1000] - timeout in milliseconds
-   * @returns {Promise<Message|void>} - a promise which resolves with the received response message, null on timeout
-   */
-  async request(msg, timeout=1000) {
+  * Sends a request and waits for a response. This method returns a {Promise} which resolves when a response
+  * is received or if no response is received after the timeout.
+  *
+  * @param {Message} msg - message to send
+  * @param {number} [timeout=opts.timeout] - timeout in milliseconds
+  * @returns {Promise<Message|void>} - a promise which resolves with the received response message, null on timeout
+  */
+  async request(msg, timeout=this._timeout) {
     this.send(msg);
     return this.receive(msg, timeout);
   }
 
   /**
-   * Returns a response message received by the gateway. This method returns a {Promise} which resolves when
-   * a response is received or if no response is received after the timeout.
-   *
-   * @param {function|Message|typeof Message} filter - original message to which a response is expected, or a MessageClass of the type
-   * of message to match, or a closure to use to match against the message
-   * @param {number} [timeout=0] - timeout in milliseconds
-   * @returns {Promise<Message|void>} - received response message, null on timeout
-   */
+  * Returns a response message received by the gateway. This method returns a {Promise} which resolves when
+  * a response is received or if no response is received after the timeout.
+  *
+  * @param {function|Message|typeof Message} filter - original message to which a response is expected, or a MessageClass of the type
+  * of message to match, or a closure to use to match against the message
+  * @param {number} [timeout=0] - timeout in milliseconds
+  * @returns {Promise<Message|void>} - received response message, null on timeout
+  */
   async receive(filter, timeout=0) {
     return new Promise(resolve => {
       let msg = this._getMessageFromQueue.call(this,filter);
@@ -1250,22 +1444,22 @@ class Gateway {
         resolve();
         return;
       }
-      let lid = _guid(8);
+      let lid = UUID7.generate().toString();
       let timer;
       if (timeout > 0){
         timer = setTimeout(() => {
-          this.listeners[lid] && delete this.listeners[lid];
+          this._pending_receives[lid] && delete this._pending_receives[lid];
           if (this.debug) console.log('Receive Timeout : ' + filter);
           resolve();
         }, timeout);
       }
       // listener for each pending receive
-      this.listeners[lid] = msg => {
+      this._pending_receives[lid] = msg => {
         // skip if the message does not match the filter
         if (msg && !this._matchMessage(filter, msg)) return false;
         if(timer) clearTimeout(timer);
         // if the message matches the filter or is null, delete listener clear timer and resolve
-        this.listeners[lid] && delete this.listeners[lid];
+        this._pending_receives[lid] && delete this._pending_receives[lid];
         resolve(msg);
         return true;
       };
@@ -1273,10 +1467,10 @@ class Gateway {
   }
 
   /**
-   * Closes the gateway. The gateway functionality may not longer be accessed after
-   * this method is called.
-   * @returns {void}
-   */
+  * Closes the gateway. The gateway functionality may not longer be accessed after
+  * this method is called.
+  * @returns {void}
+  */
   close() {
     this.connector.close();
     this._removeGWCache(this);
@@ -1284,29 +1478,302 @@ class Gateway {
 
 }
 
+const DEFAULT_TIMEOUT = 10000; // Default timeout for non-owned AgentIDs
+
+
 /**
- * Services supported by fjage agents.
- */
-const Services = {
-  SHELL : 'org.arl.fjage.shell.Services.SHELL'
-};
+* An identifier for an agent or a topic. This can be to send, receive messages, and set or get parameters
+* on an agent or topic on the fjåge master container.
+*
+* @class
+* @param {string} name - name of the agent
+* @param {boolean} [topic=false] - name of topic
+* @param {Gateway} [owner] - Gateway owner for this AgentID
+*/
+class AgentID {
+
+  constructor(name, topic=false, owner) {
+    this.name = name;
+    this.topic = topic;
+    this.owner = owner;
+    this._timeout = owner ? owner._timeout : DEFAULT_TIMEOUT; // Default timeout if owner is not provided
+  }
+
+  /**
+  * Gets the name of the agent or topic.
+  *
+  * @returns {string} - name of agent or topic
+  */
+  getName() {
+    return this.name;
+  }
+
+  /**
+  * Returns true if the agent id represents a topic.
+  *
+  * @returns {boolean} - true if the agent id represents a topic, false if it represents an agent
+  */
+  isTopic() {
+    return this.topic;
+  }
+
+  /**
+  * Sends a message to the agent represented by this id.
+  *
+  * @param {Message} msg - message to send
+  * @returns {void}
+  */
+  send(msg) {
+    msg.recipient = this;
+    if (this.owner) this.owner.send(msg);
+    else throw new Error('Unowned AgentID cannot send messages');
+  }
+
+  /**
+  * Sends a request to the agent represented by this id and waits for a reponse.
+  *
+  * @param {Message} msg - request to send
+  * @param {number} [timeout=owner.timeout] - timeout in milliseconds
+  * @returns {Promise<Message>} - response
+  */
+  async request(msg, timeout=this._timeout) {
+    msg.recipient = this;
+    if (this.owner) return this.owner.request(msg, timeout);
+    else throw new Error('Unowned AgentID cannot send messages');
+  }
+
+  /**
+  * Gets a string representation of the agent id.
+  *
+  * @returns {string} - string representation of the agent id
+  */
+  toString() {
+    return this.toJSON() + ((this.owner && this.owner.connector) ? ` on ${this.owner.connector.url}` : '');
+  }
+
+  /**
+  * Gets a JSON string representation of the agent id.
+  *
+  * @returns {string} - JSON string representation of the agent id
+  */
+  toJSON() {
+    return (this.topic ? '#' : '') + this.name;
+  }
+
+  /**
+   * Inflate the AgentID from a JSON string or object.
+   *
+   * @param {string} json - JSON string or object to be converted to an AgentID
+   * @param {Gateway} [owner] - Gateway owner for this AgentID
+   * @returns {AgentID} - AgentID created from the JSON string or object
+   */
+  static fromJSON(json, owner) {
+    if (typeof json !== 'string') {
+      throw new Error('Invalid JSON for AgentID');
+    }
+    json = json.trim();
+    if (json.startsWith('#')) {
+      return new AgentID(json.substring(1), true, owner);
+    } else {
+      return new AgentID(json, false, owner);
+    }
+  }
+
+  /**
+  * Sets parameter(s) on the Agent referred to by this AgentID.
+  *
+  * @param {(string|string[])} params - parameters name(s) to be set
+  * @param {(Object|Object[])} values - parameters value(s) to be set
+  * @param {number} [index=-1] - index of parameter(s) to be set
+  * @param {number} [timeout=owner.timeout] - timeout for the response
+  * @returns {Promise<(Object|Object[])>} - a promise which returns the new value(s) of the parameters
+  */
+  async set (params, values, index=-1, timeout=this._timeout) {
+    if (!params) return null;
+    let msg = new ParameterReq();
+    msg.recipient = this;
+    if (Array.isArray(params)){
+      if (params.length != values.length) throw new Error(`Parameters and values arrays must have the same length: ${params.length} != ${values.length}`);
+      const clonedParams = params.slice(); // Clone the array to avoid side effects
+      const clonedValues = values.slice(); // Clone the values array
+      msg.param = clonedParams.shift();
+      msg.value = clonedValues.shift();
+      msg.requests = clonedParams.map((p, i) => {
+        return {
+          'param': p,
+          'value': clonedValues[i]
+        };
+      });
+    } else {
+      msg.param = params;
+      msg.value = values;
+    }
+    msg.index = Number.isInteger(index) ? index : -1;
+    const rsp = await this.owner.request(msg, timeout);
+    var ret = Array.isArray(params) ? new Array(params.length).fill(null) : null;
+    if (!rsp || rsp.perf != Performative.INFORM || !rsp.param) {
+      if (this.owner._returnNullOnFailedResponse) return ret;
+      else throw new Error(`Unable to set ${this.name}.${params} to ${values}`);
+    }
+    if (Array.isArray(params)) {
+      if (!rsp.values) rsp.values = {};
+      if (rsp.param) rsp.values[rsp.param] = rsp.value;
+      const rkeys = Object.keys(rsp.values);
+      return params.map( p => {
+        if (p.includes('.')) p = p.split('.').pop();
+        let f = rkeys.find(k => (k.includes('.') ? k.split('.').pop() : k) == p);
+        return f ? rsp.values[f] : undefined;
+      });
+    } else {
+      return rsp.value;
+    }
+  }
+
+
+  /**
+  * Gets parameter(s) on the Agent referred to by this AgentID.
+  *
+  * @param {(string|string[])} params - parameters name(s) to be get, null implies get value of all parameters on the Agent
+  * @param {number} [index=-1] - index of parameter(s) to be get
+  * @param {number} [timeout=owner.timeout] - timeout for the response
+  * @returns {Promise<(Object|Object[])>} - a promise which returns the value(s) of the parameters
+  */
+  async get(params, index=-1, timeout=this._timeout) {
+    let msg = new ParameterReq();
+    msg.recipient = this;
+    if (params){
+      if (Array.isArray(params)) {
+        const clonedParams = params.slice(); // Clone the array to avoid side effects
+        msg.param = clonedParams.shift();
+        msg.requests = clonedParams.map(p => {return {'param': p};});
+      }
+      else msg.param = params;
+    }
+    msg.index = Number.isInteger(index) ? index : -1;
+    const rsp = await this.owner.request(msg, timeout);
+    var ret = Array.isArray(params) ? new Array(params.length).fill(null) : null;
+    if (!rsp || rsp.perf != Performative.INFORM || !rsp.param) {
+      if (this.owner._returnNullOnFailedResponse) return ret;
+      else throw new Error(`Unable to get ${this.name}.${params}`);
+    }
+    // Request for listing of all parameters.
+    if (!params) {
+      if (!rsp.values) rsp.values = {};
+      if (rsp.param) rsp.values[rsp.param] = rsp.value;
+      return rsp.values;
+    } else if (Array.isArray(params)) {
+      if (!rsp.values) rsp.values = {};
+      if (rsp.param) rsp.values[rsp.param] = rsp.value;
+      const rkeys = Object.keys(rsp.values);
+      return params.map( p => {
+        if (p.includes('.')) p = p.split('.').pop();
+        let f = rkeys.find(k => (k.includes('.') ? k.split('.').pop() : k) == p);
+        return f ? rsp.values[f] : undefined;
+      });
+    } else {
+      return rsp.value;
+    }
+  }
+}
 
 /**
- * Creates a unqualified message class based on a fully qualified name.
- * @param {string} name - fully qualified name of the message class to be created
- * @param {typeof Message} [parent] - class of the parent MessageClass to inherit from
- * @constructs Message
- * @example
- * const ParameterReq = MessageClass('org.arl.fjage.param.ParameterReq');
- * let pReq = new ParameterReq()
- */
+* Base class for messages transmitted by one agent to another. Creates an empty message.
+* @class
+*
+* @property {string} msgID - unique message ID
+* @property {Performative} perf - performative of the message
+* @property {AgentID} [sender] - AgentID of the sender of the message
+* @property {AgentID} [recipient] - AgentID of the recipient of the message
+* @property {string} [inReplyTo] - ID of the message to which this message is a response
+* @property {number} [sentAt] - timestamp when the message was sent
+*/
+class Message {
+
+  /**
+  * @param {Message} [inReplyToMsg] - message to which this message is a response
+  * @param {Performative} [perf=Performative.INFORM] - performative of the message
+  */
+  constructor(inReplyToMsg, perf=Performative.INFORM) {
+    this.__clazz__ = 'org.arl.fjage.Message';
+    this.msgID = UUID7.generate().toString();
+    this.perf = perf;
+    this.sender = null;
+    this.recipient = inReplyToMsg ? inReplyToMsg.sender : null;
+    this.inReplyTo = inReplyToMsg ? inReplyToMsg.msgID : null;
+  }
+
+  /**
+  * Gets a string representation of the message.
+  *
+  * @returns {string} - string representation
+  */
+  toString() {
+    let p = this.perf ? this.perf.toString() : 'MESSAGE';
+    if (this.__clazz__ == 'org.arl.fjage.Message') return p;
+    return p + ': ' + this.__clazz__.replace(/^.*\./, '');
+  }
+
+  /** Convert a message into a object for JSON serialization.
+  *
+  * NOTE: we don't do any base64 encoding for TX as
+  *       we don't know what data type is intended
+  *
+  * @return {Object} - JSON string representation of the message
+  */
+  toJSON() {
+    let props = {};
+    for (let key in this) {
+      if (key.startsWith('_')) continue; // skip private properties
+      // @ts-ignore
+      props[key] = this[key];
+    }
+    return { 'clazz': this.__clazz__, 'data': props };
+  }
+
+
+  /**
+  * Create a message from a object parsed from the JSON representation of the message.
+  *
+  * @param {Object} jsonObj - Object containing all the properties of the message
+  * @returns {Message} - A message created from the Object
+  *
+  */
+  static fromJSON(jsonObj) {
+    if (!( 'clazz' in jsonObj) || !( 'data' in jsonObj)) {
+      throw new Error(`Invalid Object for Message : ${jsonObj}`);
+    }
+    let qclazz = jsonObj.clazz;
+    let clazz = qclazz.replace(/^.*\./, '');
+    let rv = MessageClass[clazz] ? new MessageClass[clazz] : new Message();
+    rv.__clazz__ = qclazz;
+    // copy all properties from the data object
+    for (var key in jsonObj.data){
+      if (key === 'sender' || key === 'recipient') {
+        if (jsonObj.data[key] && typeof jsonObj.data[key] === 'string') {
+          rv[key] = AgentID.fromJSON(jsonObj.data[key]);
+        }
+      } else rv[key] = jsonObj.data[key];
+    }
+    return rv;
+  }
+}
+
+/**
+* Creates a unqualified message class based on a fully qualified name.
+* @param {string} name - fully qualified name of the message class to be created
+* @param {typeof Message} [parent] - class of the parent MessageClass to inherit from
+* @constructs Message
+* @example
+* const ParameterReq = MessageClass('org.arl.fjage.param.ParameterReq');
+* let pReq = new ParameterReq()
+*/
 function MessageClass(name, parent=Message) {
   let sname = name.replace(/^.*\./, '');
   if (MessageClass[sname]) return MessageClass[sname];
   let cls = class extends parent {
     /**
-     * @param {{ [x: string]: any; }} params
-     */
+    * @param {{ [x: string]: any; }} params
+    */
     constructor(params) {
       super();
       this.__clazz__ = name;
@@ -1324,134 +1791,67 @@ function MessageClass(name, parent=Message) {
   return cls;
 }
 
-////// private utilities
-
-// generate random ID with length 4*len characters
-/** @private */
-function _guid(len) {
-  function s4() {
-    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
-  }
-  let s = s4();
-  for (var i = 0; i < len-1; i++)
-    s += s4();
-  return s;
-}
-
-// convert from base 64 to array
-/** @private */
-function _b64toArray(base64, dtype, littleEndian=true) {
-  let s = gObj.atob(base64);
-  let len = s.length;
-  let bytes = new Uint8Array(len);
-  for (var i = 0; i < len; i++)
-    bytes[i] = s.charCodeAt(i);
-  let rv = [];
-  let view = new DataView(bytes.buffer);
-  switch (dtype) {
-  case '[B': // byte array
-    for (i = 0; i < len; i++)
-      rv.push(view.getUint8(i));
-    break;
-  case '[S': // short array
-    for (i = 0; i < len; i+=2)
-      rv.push(view.getInt16(i, littleEndian));
-    break;
-  case '[I': // integer array
-    for (i = 0; i < len; i+=4)
-      rv.push(view.getInt32(i, littleEndian));
-    break;
-  case '[J': // long array
-    for (i = 0; i < len; i+=8)
-      rv.push(view.getBigInt64(i, littleEndian));
-    break;
-  case '[F': // float array
-    for (i = 0; i < len; i+=4)
-      rv.push(view.getFloat32(i, littleEndian));
-    break;
-  case '[D': // double array
-    for (i = 0; i < len; i+=8)
-      rv.push(view.getFloat64(i, littleEndian));
-    break;
-  default:
-    return;
-  }
-  return rv;
-}
-
-// base 64 JSON decoder
-/** @private */
-function _decodeBase64(k, d) {
-  if (d === null) {
-    return null;
-  }
-  if (typeof d == 'object' && 'clazz' in d) {
-    let clazz = d.clazz;
-    if (clazz.startsWith('[') && clazz.length == 2 && 'data' in d) {
-      let x = _b64toArray(d.data, d.clazz);
-      if (x) d = x;
-    }
-  }
-  return d;
-}
-
-////// global
-
-const GATEWAY_DEFAULTS = {};
-
-/** @type {Window & globalThis & Object} */
-let gObj = {};
-let DEFAULT_URL;
-if (isBrowser || isWebWorker){
-  gObj = window;
-  Object.assign(GATEWAY_DEFAULTS, {
-    'hostname': gObj.location.hostname,
-    'port': gObj.location.port,
-    'pathname' : '/ws/',
-    'timeout': 1000,
-    'keepAlive' : true,
-    'queueSize': DEFAULT_QUEUE_SIZE,
-    'returnNullOnFailedResponse': true,
-    'cancelPendingOnDisconnect': false
-  });
-  DEFAULT_URL = new URL('ws://localhost');
-  // Enable caching of Gateways
-  if (typeof gObj.fjage === 'undefined') gObj.fjage = {};
-  if (typeof gObj.fjage.gateways == 'undefined') gObj.fjage.gateways = [];
-} else if (isJsDom || isNode){
-  gObj = global;
-  Object.assign(GATEWAY_DEFAULTS, {
-    'hostname': 'localhost',
-    'port': '1100',
-    'pathname': '',
-    'timeout': 1000,
-    'keepAlive' : true,
-    'queueSize': DEFAULT_QUEUE_SIZE,
-    'returnNullOnFailedResponse': true,
-    'cancelPendingOnDisconnect': false
-  });
-  DEFAULT_URL = new URL('tcp://localhost');
-  gObj.atob = a => Buffer.from(a, 'base64').toString('binary');
-}
+/**
+* @typedef {Object} ParameterReq.Entry
+* @property {string} param - parameter name
+* @property {Object} value - parameter value
+* @exports ParameterReq.Entry
+*/
 
 /**
- * @typedef {Object} ParameterReq.Entry
- * @property {string} param - parameter name
- * @property {Object} value - parameter value
- * @exports ParameterReq.Entry
- */
+* A message that requests one or more parameters of an agent.
+*
+* @example <caption>Setting a parameter myAgent.x to 42</caption>
+* let req = new ParameterReq({
+*  recipient: myAgentId,
+*  param: 'x',
+*  value: 42
+* });
+*
+* @example <caption>Getting the value of myAgent.x</caption>
+* let req = new ParameterReq({
+* recipient: myAgentId,
+* param: 'x'
+* });
+*
+* @typedef {Message} ParameterReq
+* @property {string} param - parameters name to be get/set if only a single parameter is to be get/set
+* @property {Object} value - parameters value to be set if only a single parameter is to be set
+* @property {Array<ParameterReq.Entry>} requests - a list of multiple parameters to be get/set
+* @property {number} [index=-1] - index of parameter(s) to be set*
+* @exports ParameterReq
+*/
+const ParameterReq = MessageClass('org.arl.fjage.param.ParameterReq');
 
+/**
+* A message that is a response to a {@link ParameterReq} message.
+*
+* @example <caption>Receiving a parameter from myAgent</caption>
+* let rsp = gw.receive(ParameterRsp)
+* rsp.sender // = myAgentId; sender of the message
+* rsp.param  // = 'x'; parameter name that was get/set
+* rsp.value  // = 42;  value of the parameter that was set
+* rsp.readonly // = [false]; indicates if the parameter is read-only
+*
+*
+* @typedef {Message} ParameterRsp
+* @property {string} param - parameters name if only a single parameter value was requested
+* @property {Object} value - parameters value if only a single parameter was requested
+* @property {Map<string, Object>} values - a map of multiple parameter names and their values if multiple parameters were requested
+* @property {Array<boolean>} readonly - a list of booleans indicating if the parameters are read-only
+* @property {number} [index=-1] - index of parameter(s) being returned
+* @exports ParameterReq
+*/
+MessageClass('org.arl.fjage.param.ParameterRsp');
 
 /**
- * A message that requests one or more parameters of an agent.
- * @typedef {Message} ParameterReq
- * @property {string} param - parameters name to be get/set if only a single parameter is to be get/set
- * @property {Object} value - parameters value to be set if only a single parameter is to be set
- * @property {Array<ParameterReq.Entry>} requests - a list of multiple parameters to be get/set
- * @property {number} [index=-1] - index of parameter(s) to be set
- * @exports ParameterReq
- */
-const ParameterReq = MessageClass('org.arl.fjage.param.ParameterReq');
+* Services supported by fjage agents.
+*/
+const Services = {
+  SHELL : 'org.arl.fjage.shell.Services.SHELL'
+};
+
+init();
 
 const DatagramReq$1 = MessageClass('org.arl.unet.DatagramReq');
 const DatagramNtf$1 = MessageClass('org.arl.unet.DatagramNtf');
@@ -2106,34 +2506,31 @@ class UnetSocket {
   /**
    * Gets an AgentID providing a specified service for low-level access to UnetStack
    * @param {string} svc - the named service of interest
-   * @param {Boolean} caching - if the AgentID should cache parameters
    * @returns {Promise<?AgentID>} - a promise which returns an {@link AgentID} that provides the service when resolved
    */
-  async agentForService(svc, caching=true) {
+  async agentForService(svc) {
     if (this.gw == null) return null;
-    return await this.gw.agentForService(svc, caching);
+    return await this.gw.agentForService(svc);
   }
 
   /**
    *
    * @param {string} svc - the named service of interest
-   * @param {Boolean} caching - if the AgentID should cache parameters
    * @returns {Promise<AgentID[]>} - a promise which returns an array of {@link AgentID|AgentIDs} that provides the service when resolved
    */
-  async agentsForService(svc, caching=true) {
+  async agentsForService(svc) {
     if (this.gw == null) return null;
-    return await this.gw.agentsForService(svc, caching``);
+    return await this.gw.agentsForService(svc);
   }
 
   /**
    * Gets a named AgentID for low-level access to UnetStack.
    * @param {string} name - name of agent
-   * @param {Boolean} caching - if the AgentID should cache parameters
    * @returns {AgentID} - AgentID for the given name
    */
-  agent(name, caching=true) {
+  agent(name) {
     if (this.gw == null) return null;
-    return this.gw.agent(name, caching);
+    return this.gw.agent(name);
   }
 
   /**