unetjs 1.0.0 → 2.0.0

package/dist/esm/unet.js

@@ -1,6 +1,6 @@
-/* unet.js v1.0.0 2021-07-07T04:11:04.914Z */
+/* unet.js v2.0.0 2022-05-18T02:36:38.084Z */
 
-/* fjage.js v1.9.1-rc5 2021-07-07T04:07:53.061Z */
+/* fjage.js v1.9.1-rc6 */
 
 /* global window self */
 
@@ -1271,6 +1271,8 @@ let UnetServices = {
   'TRANSPORT': 'org.arl.unet.Services.TRANSPORT',
   'REMOTE': 'org.arl.unet.Services.REMOTE',
   'STATE_MANAGER': 'org.arl.unet.Services.STATE_MANAGER',
+  'DEVICE_INFO': 'org.arl.unet.Services.DEVICE_INFO',
+  'DOA': 'org.arl.unet.Services.DOA'
 };
 
 Object.assign(Services, UnetServices);
@@ -1299,100 +1301,361 @@ let Protocol = {
  */
 let UnetMessages = {
   // unet
-  'TestReportNtf'          : MessageClass('org.arl.unet.TestReportNtf'), 
-  'AbnormalTerminationNtf' : MessageClass('org.arl.unet.AbnormalTerminationNtf'), 
-  'CapabilityListRsp'      : MessageClass('org.arl.unet.CapabilityListRsp'), 
-  'CapabilityReq'          : MessageClass('org.arl.unet.CapabilityReq'), 
-  'ClearReq'               : MessageClass('org.arl.unet.ClearReq'), 
-  'DatagramCancelReq'      : MessageClass('org.arl.unet.DatagramCancelReq'), 
-  'DatagramDeliveryNtf'    : MessageClass('org.arl.unet.DatagramDeliveryNtf'), 
-  'DatagramFailureNtf'     : MessageClass('org.arl.unet.DatagramFailureNtf'), 
-  'DatagramNtf'            : MessageClass('org.arl.unet.DatagramNtf'), 
-  'DatagramProgressNtf'    : MessageClass('org.arl.unet.DatagramProgressNtf'), 
-  'DatagramReq'            : MessageClass('org.arl.unet.DatagramReq'), 
-  'ParamChangeNtf'         : MessageClass('org.arl.unet.ParamChangeNtf'), 
-  'RefuseRsp'              : MessageClass('org.arl.unet.RefuseRsp'), 
-  'FailureNtf'             : MessageClass('org.arl.unet.FailureNtf'), 
+  'TestReportNtf'          : MessageClass('org.arl.unet.TestReportNtf'),
+  'AbnormalTerminationNtf' : MessageClass('org.arl.unet.AbnormalTerminationNtf'),
+  'CapabilityListRsp'      : MessageClass('org.arl.unet.CapabilityListRsp'),
+  'CapabilityReq'          : MessageClass('org.arl.unet.CapabilityReq'),
+  'ClearReq'               : MessageClass('org.arl.unet.ClearReq'),
+  'DatagramCancelReq'      : MessageClass('org.arl.unet.DatagramCancelReq'),
+  'DatagramDeliveryNtf'    : MessageClass('org.arl.unet.DatagramDeliveryNtf'),
+  'DatagramFailureNtf'     : MessageClass('org.arl.unet.DatagramFailureNtf'),
+  'DatagramNtf'            : MessageClass('org.arl.unet.DatagramNtf'),
+  'DatagramProgressNtf'    : MessageClass('org.arl.unet.DatagramProgressNtf'),
+  'DatagramReq'            : MessageClass('org.arl.unet.DatagramReq'),
+  'ParamChangeNtf'         : MessageClass('org.arl.unet.ParamChangeNtf'),
+  'RefuseRsp'              : MessageClass('org.arl.unet.RefuseRsp'),
+  'FailureNtf'             : MessageClass('org.arl.unet.FailureNtf'),
 
   // net
-  'DatagramTraceReq'       : MessageClass('org.arl.unet.net.DatagramTraceReq'), 
-  'RouteDiscoveryReq'      : MessageClass('org.arl.unet.net.RouteDiscoveryReq'), 
-  'RouteTraceReq'          : MessageClass('org.arl.unet.net.RouteTraceReq'), 
-  'RouteDiscoveryNtf'      : MessageClass('org.arl.unet.net.RouteDiscoveryNtf'), 
-  'RouteTraceNtf'          : MessageClass('org.arl.unet.net.RouteTraceNtf'), 
+  'DatagramTraceReq'       : MessageClass('org.arl.unet.net.DatagramTraceReq'),
+  'RouteDiscoveryReq'      : MessageClass('org.arl.unet.net.RouteDiscoveryReq'),
+  'RouteTraceReq'          : MessageClass('org.arl.unet.net.RouteTraceReq'),
+  'RouteDiscoveryNtf'      : MessageClass('org.arl.unet.net.RouteDiscoveryNtf'),
+  'RouteTraceNtf'          : MessageClass('org.arl.unet.net.RouteTraceNtf'),
 
   // phy
-  'FecDecodeReq'           : MessageClass('org.arl.unet.phy.FecDecodeReq'), 
-  'RxJanusFrameNtf'        : MessageClass('org.arl.unet.phy.RxJanusFrameNtf'), 
-  'TxJanusFrameReq'        : MessageClass('org.arl.unet.phy.TxJanusFrameReq'), 
-  'BadFrameNtf'            : MessageClass('org.arl.unet.phy.BadFrameNtf'), 
+  'FecDecodeReq'           : MessageClass('org.arl.unet.phy.FecDecodeReq'),
+  'RxJanusFrameNtf'        : MessageClass('org.arl.unet.phy.RxJanusFrameNtf'),
+  'TxJanusFrameReq'        : MessageClass('org.arl.unet.phy.TxJanusFrameReq'),
+  'BadFrameNtf'            : MessageClass('org.arl.unet.phy.BadFrameNtf'),
   'BadRangeNtf'            : MessageClass('org.arl.unet.phy.BadRangeNtf'),
-  'ClearSyncReq'           : MessageClass('org.arl.unet.phy.ClearSyncReq'), 
-  'CollisionNtf'           : MessageClass('org.arl.unet.phy.CollisionNtf'), 
-  'RxFrameNtf'             : MessageClass('org.arl.unet.phy.RxFrameNtf', DatagramNtf$1), 
-  'RxFrameStartNtf'        : MessageClass('org.arl.unet.phy.RxFrameStartNtf'), 
-  'SyncInfoReq'            : MessageClass('org.arl.unet.phy.SyncInfoReq'), 
-  'SyncInfoRsp'            : MessageClass('org.arl.unet.phy.SyncInfoRsp'), 
-  'TxFrameNtf'             : MessageClass('org.arl.unet.phy.TxFrameNtf'), 
-  'TxFrameReq'             : MessageClass('org.arl.unet.phy.TxFrameReq', DatagramReq$1), 
-  'TxFrameStartNtf'        : MessageClass('org.arl.unet.phy.TxFrameStartNtf'), 
-  'TxRawFrameReq'          : MessageClass('org.arl.unet.phy.TxRawFrameReq'), 
+  'ClearSyncReq'           : MessageClass('org.arl.unet.phy.ClearSyncReq'),
+  'CollisionNtf'           : MessageClass('org.arl.unet.phy.CollisionNtf'),
+  'RxFrameNtf'             : MessageClass('org.arl.unet.phy.RxFrameNtf', DatagramNtf$1),
+  'RxFrameStartNtf'        : MessageClass('org.arl.unet.phy.RxFrameStartNtf'),
+  'SyncInfoReq'            : MessageClass('org.arl.unet.phy.SyncInfoReq'),
+  'SyncInfoRsp'            : MessageClass('org.arl.unet.phy.SyncInfoRsp'),
+  'TxFrameNtf'             : MessageClass('org.arl.unet.phy.TxFrameNtf'),
+  'TxFrameReq'             : MessageClass('org.arl.unet.phy.TxFrameReq', DatagramReq$1),
+  'TxFrameStartNtf'        : MessageClass('org.arl.unet.phy.TxFrameStartNtf'),
+  'TxRawFrameReq'          : MessageClass('org.arl.unet.phy.TxRawFrameReq'),
 
   // addr
-  'AddressAllocReq'        : MessageClass('org.arl.unet.addr.AddressAllocReq'), 
-  'AddressAllocRsp'        : MessageClass('org.arl.unet.addr.AddressAllocRsp'), 
-  'AddressResolutionReq'   : MessageClass('org.arl.unet.addr.AddressResolutionReq'), 
-  'AddressResolutionRsp'   : MessageClass('org.arl.unet.addr.AddressResolutionRsp'), 
+  'AddressAllocReq'        : MessageClass('org.arl.unet.addr.AddressAllocReq'),
+  'AddressAllocRsp'        : MessageClass('org.arl.unet.addr.AddressAllocRsp'),
+  'AddressResolutionReq'   : MessageClass('org.arl.unet.addr.AddressResolutionReq'),
+  'AddressResolutionRsp'   : MessageClass('org.arl.unet.addr.AddressResolutionRsp'),
 
   // bb
-  'BasebandSignal'         : MessageClass('org.arl.unet.bb.BasebandSignal'), 
-  'RecordBasebandSignalReq' : MessageClass('org.arl.unet.bb.RecordBasebandSignalReq'), 
-  'RxBasebandSignalNtf'    : MessageClass('org.arl.unet.bb.RxBasebandSignalNtf', BasebandSignal), 
-  'TxBasebandSignalReq'    : MessageClass('org.arl.unet.bb.TxBasebandSignalReq', BasebandSignal), 
+  'BasebandSignal'         : MessageClass('org.arl.unet.bb.BasebandSignal'),
+  'RecordBasebandSignalReq' : MessageClass('org.arl.unet.bb.RecordBasebandSignalReq'),
+  'RxBasebandSignalNtf'    : MessageClass('org.arl.unet.bb.RxBasebandSignalNtf', BasebandSignal),
+  'TxBasebandSignalReq'    : MessageClass('org.arl.unet.bb.TxBasebandSignalReq', BasebandSignal),
 
   // link
-  'LinkStatusNtf'          : MessageClass('org.arl.unet.link.LinkStatusNtf'), 
+  'LinkStatusNtf'          : MessageClass('org.arl.unet.link.LinkStatusNtf'),
 
   // localization
-  'RangeNtf'               : MessageClass('org.arl.unet.localization.RangeNtf'), 
-  'RangeReq'               : MessageClass('org.arl.unet.localization.RangeReq'), 
-  'BeaconReq'              : MessageClass('org.arl.unet.localization.BeaconReq'), 
-  'RespondReq'             : MessageClass('org.arl.unet.localization.RespondReq'), 
-  'InterrogationNtf'       : MessageClass('org.arl.unet.localization.InterrogationNtf'), 
+  'RangeNtf'               : MessageClass('org.arl.unet.localization.RangeNtf'),
+  'RangeReq'               : MessageClass('org.arl.unet.localization.RangeReq'),
+  'BeaconReq'              : MessageClass('org.arl.unet.localization.BeaconReq'),
+  'RespondReq'             : MessageClass('org.arl.unet.localization.RespondReq'),
+  'InterrogationNtf'       : MessageClass('org.arl.unet.localization.InterrogationNtf'),
 
 
   // mac
-  'ReservationAcceptReq'   : MessageClass('org.arl.unet.mac.ReservationAcceptReq'), 
-  'ReservationCancelReq'   : MessageClass('org.arl.unet.mac.ReservationCancelReq'), 
-  'ReservationReq'         : MessageClass('org.arl.unet.mac.ReservationReq'), 
-  'ReservationRsp'         : MessageClass('org.arl.unet.mac.ReservationRsp'), 
-  'ReservationStatusNtf'   : MessageClass('org.arl.unet.mac.ReservationStatusNtf'), 
-  'RxAckNtf'               : MessageClass('org.arl.unet.mac.RxAckNtf'), 
-  'TxAckReq'               : MessageClass('org.arl.unet.mac.TxAckReq'), 
+  'ReservationAcceptReq'   : MessageClass('org.arl.unet.mac.ReservationAcceptReq'),
+  'ReservationCancelReq'   : MessageClass('org.arl.unet.mac.ReservationCancelReq'),
+  'ReservationReq'         : MessageClass('org.arl.unet.mac.ReservationReq'),
+  'ReservationRsp'         : MessageClass('org.arl.unet.mac.ReservationRsp'),
+  'ReservationStatusNtf'   : MessageClass('org.arl.unet.mac.ReservationStatusNtf'),
+  'RxAckNtf'               : MessageClass('org.arl.unet.mac.RxAckNtf'),
+  'TxAckReq'               : MessageClass('org.arl.unet.mac.TxAckReq'),
 
 
   // remote
-  'RemoteExecReq'          : MessageClass('org.arl.unet.remote.RemoteExecReq'), 
-  'RemoteFailureNtf'       : MessageClass('org.arl.unet.remote.RemoteFailureNtf'), 
-  'RemoteFileGetReq'       : MessageClass('org.arl.unet.remote.RemoteFileGetReq'), 
-  'RemoteFileNtf'          : MessageClass('org.arl.unet.remote.RemoteFileNtf'), 
-  'RemoteFilePutReq'       : MessageClass('org.arl.unet.remote.RemoteFilePutReq'), 
-  'RemoteSuccessNtf'       : MessageClass('org.arl.unet.remote.RemoteSuccessNtf'), 
-  'RemoteTextNtf'          : MessageClass('org.arl.unet.remote.RemoteTextNtf'), 
-  'RemoteTextReq'          : MessageClass('org.arl.unet.remote.RemoteTextReq'), 
+  'RemoteExecReq'          : MessageClass('org.arl.unet.remote.RemoteExecReq'),
+  'RemoteFailureNtf'       : MessageClass('org.arl.unet.remote.RemoteFailureNtf'),
+  'RemoteFileGetReq'       : MessageClass('org.arl.unet.remote.RemoteFileGetReq'),
+  'RemoteFileNtf'          : MessageClass('org.arl.unet.remote.RemoteFileNtf'),
+  'RemoteFilePutReq'       : MessageClass('org.arl.unet.remote.RemoteFilePutReq'),
+  'RemoteSuccessNtf'       : MessageClass('org.arl.unet.remote.RemoteSuccessNtf'),
+  'RemoteTextNtf'          : MessageClass('org.arl.unet.remote.RemoteTextNtf'),
+  'RemoteTextReq'          : MessageClass('org.arl.unet.remote.RemoteTextReq'),
 
   // scheduler
-  'AddScheduledSleepReq'   : MessageClass('org.arl.unet.scheduler.AddScheduledSleepReq'), 
-  'GetSleepScheduleReq'    : MessageClass('org.arl.unet.scheduler.GetSleepScheduleReq'), 
-  'RemoveScheduledSleepReq' : MessageClass('org.arl.unet.scheduler.RemoveScheduledSleepReq'), 
-  'SleepScheduleRsp'       : MessageClass('org.arl.unet.scheduler.SleepScheduleRsp'), 
-  'WakeFromSleepNtf'       : MessageClass('org.arl.unet.scheduler.WakeFromSleepNtf'), 
+  'AddScheduledSleepReq'   : MessageClass('org.arl.unet.scheduler.AddScheduledSleepReq'),
+  'GetSleepScheduleReq'    : MessageClass('org.arl.unet.scheduler.GetSleepScheduleReq'),
+  'RemoveScheduledSleepReq' : MessageClass('org.arl.unet.scheduler.RemoveScheduledSleepReq'),
+  'SleepScheduleRsp'       : MessageClass('org.arl.unet.scheduler.SleepScheduleRsp'),
+  'WakeFromSleepNtf'       : MessageClass('org.arl.unet.scheduler.WakeFromSleepNtf'),
 
   // state
-  'ClearStateReq'          : MessageClass('org.arl.unet.state.ClearStateReq'), 
+  'ClearStateReq'          : MessageClass('org.arl.unet.state.ClearStateReq'),
   'SaveStateReq'           : MessageClass('org.arl.unet.state.SaveStateReq')
 };
 
+/**
+  * Convert coordinates from a local coordinates to GPS coordinate
+  * @param {Array} origin - Local coordinate system's origin as `[latitude, longitude]`
+  * @param {Number} x - X coordinate of the local coordinate to be converted
+  * @param {Number} y - Y coordinate of the local coordinate to be converted
+  * @returns {Array} - GPS coordinates (in decimal degrees) as `[latitude, longitude]`
+  */
+
+function toGps(origin, x, y) {
+  let coords = [] ;
+  let [xScale,yScale] = _initConv(origin[0]);
+  coords[1] = x/xScale + origin[1];
+  coords[0] = y/yScale + origin[0];
+  return coords;
+}
+
+/**
+  * Convert coordinates from a GPS coordinates to local coordinate
+  * @param {Array} origin - Local coordinate system's origin as `[latitude, longitude]`
+  * @param {Number} lat - Latitude of the GPS coordinate to be converted
+  * @param {Number} lon - Longitude of the GPS coordinate to be converted
+  * @returns {Array} - GPS coordinates (in decimal degrees) as `[latitude, longitude]`
+  */
+function toLocal(origin, lat, lon) {
+  let pos = [];
+  let [xScale,yScale] = _initConv(origin[0]);
+  pos[0] = (lon-origin[1]) * xScale;
+  pos[1] = (lat-origin[0]) * yScale;
+  return pos;
+}
+
+function _initConv(lat){
+  let rlat = lat * Math.PI/180;
+  let yScale = 111132.92 - 559.82*Math.cos(2*rlat) + 1.175*Math.cos(4*rlat) - 0.0023*Math.cos(6*rlat);
+  let xScale = 111412.84*Math.cos(rlat) - 93.5*Math.cos(3*rlat) + 0.118*Math.cos(5*rlat);
+  return [xScale, yScale];
+}
+
+/**
+ * A message which requests the transmission of the datagram from the Unet
+ *
+ * @typedef {Message} DatagramReq
+ * @property {number[]} data - data as an Array of bytes
+ * @property {number} from - from/source node address
+ * @property {number} to - to/destination node address
+ * @property {number} protocol - protocol number to be used to send this Datagram
+ * @property {boolean} reliability - true if Datagram should be reliable, false if unreliable
+ * @property {number} ttl - time-to-live for the datagram. Time-to-live is advisory, and an agent may choose it ignore it
+ */
+
+/**
+ * Notification of received datagram message received by the Unet node.
+ *
+ * @typedef {Message} DatagramNtf
+ * @property {number[]} data - data as an Array of bytes
+ * @property {number} from - from/source node address
+ * @property {number} to - to/destination node address
+ * @property {number} protocol - protocol number to be used to send this Datagram
+ * @property {number} ttl - time-to-live for the datagram. Time-to-live is advisory, and an agent may choose it ignore it
+ */
+
+/**
+ * An identifier for an agent or a topic.
+ * @external AgentID
+ * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+ */
+
+/**
+ * Services supported by fjage agents.
+ * @external Services
+ * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+ */
+
+/**
+ *  An action represented by a message.
+ * @external Performative
+ * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+ */
+
+/**
+ * Function to creates a unqualified message class based on a fully qualified name.
+ * @external MessageClass
+ * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+ */
+
+/**
+ * A caching CachingAgentID which caches Agent parameters locally.
+ *
+ * @class
+ * @extends AgentID
+ * @param {string | AgentID} name - name of the agent or an AgentID to copy
+ * @param {boolean} topic - name of topic
+ * @param {Gateway} owner - Gateway owner for this AgentID
+ * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+ *
+*/
+class CachingAgentID extends AgentID {
+
+  constructor(name, topic, owner, greedy=true) {
+    if (name instanceof AgentID) {
+      super(name.getName(), name.topic, name.owner);
+    } else {
+      super(name, topic, owner);
+    }
+    this.greedy = greedy;
+    this.cache = {};
+  }
+
+  /**
+   * Sets parameter(s) on the Agent referred to by this AgentID, and caches the parameter(s).
+   *
+   * @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) {
+    let s = await super.set(params, values, index, timeout);
+    this._updateCache(params, s, index);
+  }
+
+  /**
+   * Gets parameter(s) on the Agent referred to by this AgentID, getting them from the cache if possible.
+   *
+   * @param {(string|string[])} params - parameters name(s) to be fetched
+   * @param {number} [index=-1] - index of parameter(s) to be fetched
+   * @param {number} [timeout=5000] - timeout for the response
+   * @param {number} [maxage=5000] - maximum age of the cached result to retreive
+   * @returns {Promise<(Object|Object[])>} - a promise which returns the value(s) of the parameters
+   */
+  async get(params, index=-1, timeout=5000, maxage=5000) {
+    if (this._isCached(params, index, maxage)) return this._getCache(params, index);
+    if (this.greedy && !(Array.isArray(params) && params.includes('name')) && params != 'name') {
+      let rsp = await super.get(null, index, timeout);
+      this._updateCache(null, rsp, index);
+      if (Array.isArray(params)) {
+        return params.map(p => {
+          let f = Object.keys(rsp).find(rv => this._toNamed(rv) === p);
+          return f ? rsp[f] : null;
+        });
+      } else {
+        let f = Object.keys(rsp).find(rv => this._toNamed(rv) === params);
+        return f ? rsp[f] : null;
+      }
+    } else {
+      let r = await super.get(params, index, timeout);
+      this._updateCache(params, r, index);
+      return r;
+    }
+  }
+
+  _updateCache(params, vals, index) {
+    if (vals == null || Array.isArray(vals) && vals.every(v => v == null)) return;
+    if (params == null) {
+      params = Object.keys(vals);
+      vals = Object.values(vals);
+    } else if (!Array.isArray(params)) params = [params];
+    if (!Array.isArray(vals)) vals = [vals];
+    params = params.map(this._toNamed);
+    if (this.cache[index.toString()] === undefined) this.cache[index.toString()] = {};
+    let c = this.cache[index.toString()];
+    for (let i = 0; i < params.length; i++) {
+      if (c[params[i]] === undefined) c[params[i]] = {};
+      c[params[i]].value = vals[i];
+      c[params[i]].ctime = Date.now();
+    }
+  }
+
+  _isCached(params, index, maxage) {
+    if (maxage <= 0) return false;
+    if (params == null) return false;
+    let c = this.cache[index.toString()];
+    if (!c) {
+      return false;
+    }
+    if (!Array.isArray(params)) params = [params];
+    const rv = params.every(p => {
+      p = this._toNamed(p);
+      return (p in c) && (Date.now() - c[p].ctime <= maxage);
+    });
+    return rv;
+  }
+
+  _getCache(params, index) {
+    let c = this.cache[index.toString()];
+    if (!c) return null;
+    if (!Array.isArray(params)){
+      if (params in c) return c[params].value;
+      return null;
+    }else {
+      return params.map(p => p in c ? c[p].value : null);
+    }
+  }
+
+  _toNamed(param) {
+    const idx = param.lastIndexOf('.');
+    if (idx < 0) return param;
+    else return param.slice(idx+1);
+  }
+
+}
+
+
+class CachingGateway extends Gateway{
+
+  /**
+   * Get an AgentID for a given agent name.
+   *
+   * @param {string} name - name of agent
+   * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+   * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+   * @returns {AgentID|CachingAgentID} - AgentID for the given name
+   */
+  agent(name, caching=true, greedy=true) {
+    const aid = super.agent(name);
+    return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+  }
+
+  /**
+   * 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
+   * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+   * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+   * @returns {AgentID|CachingAgentID} - object representing the topic
+   */
+  topic(topic, topic2, caching=true, greedy=true) {
+    const aid = super.topic(topic, topic2);
+    return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+  }
+
+  /**
+   * 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 {Boolean} [caching=true] - if the AgentID should cache parameters
+   * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+   * @returns {Promise<?AgentID|CachingAgentID>} - a promise which returns an agent id for an agent that provides the service when resolved
+   */
+  async agentForService(service, caching=true, greedy=true) {
+    const aid = await super.agentForService(service);
+    return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+  }
+
+  /**
+   * Finds all agents that provides a named service.
+   *
+   * @param {string} service - the named service of interest
+   * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+   * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+   * @returns {Promise<?AgentID|CachingAgentID[]>} - a promise which returns an array of all agent ids that provides the service when resolved
+   */
+  async agentsForService(service, caching=true, greedy=true) {
+    const aids = await super.agentsForService(service);
+    return caching ? aids.map(a => new CachingAgentID(a, null, null, greedy)) : aids;
+  }
+}
+
 const REQUEST_TIMEOUT = 1000;
 
 const AddressResolutionReq = UnetMessages.AddressResolutionReq;
@@ -1401,26 +1664,26 @@ const DatagramNtf = UnetMessages.DatagramNtf;
 const RxFrameNtf = UnetMessages.RxFrameNtf;
 
 /**
- * Creates a new UnetSocket to connect to a running Unet instance. This constructor returns a 
- * {@link Promise} instead of the constructed UnetSocket object. Use `await` or `.then()` to get 
- * a reference to the UnetSocket object. Based on if this is run in a Browser or Node.js, 
+ * Creates a new UnetSocket to connect to a running Unet instance. This constructor returns a
+ * {@link Promise} instead of the constructed UnetSocket object. Use `await` or `.then()` to get
+ * a reference to the UnetSocket object. Based on if this is run in a Browser or Node.js,
  * it will internally connect over WebSockets or TCP respectively.
  *
- * 
+ *
  * @class UnetSocket
  * @param {string} [hostname] - hostname/ip address of the master container to connect to
  * @param {number} [port] - port number of the master container to connect to
  * @param {string} [path='']  - path of the master container to connect to (for WebSockets)
  * @returns {Promise<UnetSocket>} - Promise which resolves to the UnetSocket object being constructed
- * 
+ *
  * @example
  * let socket = await new UnetSocket('localhost', 8081, '/ws/');
  */
 class UnetSocket {
 
-  constructor(hostname, port, path='') { 
+  constructor(hostname, port, path='') {
     return (async () => {
-      this.gw = new Gateway({
+      this.gw = new CachingGateway({
         hostname : hostname,
         port : port,
         path : path
@@ -1449,13 +1712,13 @@ class UnetSocket {
    * Checks if a socket is closed.
    * @returns {boolean} - true if closed, false if open
    */
-  isClosed() { 
+  isClosed() {
     return this.gw == null;
   }
 
   /**
    * Binds a socket to listen to a specific protocol datagrams.
-   * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are reserved protocols 
+   * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are reserved protocols
    * and cannot be bound. Unbound sockets listen to all unreserved
    * @param {Protocol} protocol - protocol number to listen for
    * @returns {boolean} - true on success, false on failure
@@ -1467,9 +1730,9 @@ class UnetSocket {
     }
     return false;
   }
-  
+
   /**
-   * Unbinds a socket so that it listens to all unreserved protocols. 
+   * Unbinds a socket so that it listens to all unreserved protocols.
    * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved.
    * @returns {void}
    */
@@ -1482,13 +1745,13 @@ class UnetSocket {
   isBound() { return this.localProtocol >= 0;}
 
   /**
-   * Sets the default destination address and destination protocol number for datagrams sent 
-   * using this socket. The defaults can be overridden for specific send() calls. 
-   * The default protcol number when a socket is opened is Protcol.DATA. 
-   * The default node address is undefined. 
-   * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved, 
+   * Sets the default destination address and destination protocol number for datagrams sent
+   * using this socket. The defaults can be overridden for specific send() calls.
+   * The default protcol number when a socket is opened is Protcol.DATA.
+   * The default node address is undefined.
+   * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved,
    * and cannot be used for sending datagrams using the socket.
-   * 
+   *
    * @param {number} to - default destination node address
    * @param {Protocol} protocol - default protocol number
    * @returns {boolean} - true on success, false on failure
@@ -1503,11 +1766,11 @@ class UnetSocket {
   }
 
   /**
-   * Resets the default destination address to undefined, and the default protocol number 
+   * Resets the default destination address to undefined, and the default protocol number
    * to Protocol.DATA.
    * @returns {void}
    */
-  disconnect() { 
+  disconnect() {
     this.remoteAddress = -1;
     this.remoteProtocol = 0;
   }
@@ -1522,7 +1785,7 @@ class UnetSocket {
    * Gets the local node address of the Unet node connected to.
    * @returns {Promise<int>} - local node address, or -1 on error
    */
-  async getLocalAddress() { 
+  async getLocalAddress() {
     if (this.gw == null) return -1;
     const nodeinfo = await this.gw.agentForService(Services.NODE_INFO);
     if (nodeinfo == null) return -1;
@@ -1549,14 +1812,14 @@ class UnetSocket {
   getRemoteProtocol() { return this.remoteProtocol; }
 
   /**
-   * Sets the timeout for datagram reception. A timeout of 0 means the 
-   * {@link UnetSocket#receive|receive method} will check any appropriate 
+   * Sets the timeout for datagram reception. A timeout of 0 means the
+   * {@link UnetSocket#receive|receive method} will check any appropriate
    * Datagram has already been received (and is cached) else return immediately.
-   * 
+   *
    * @param {number} ms - timeout in milliseconds
    * @returns {void}
    */
-  setTimeout(ms) { 
+  setTimeout(ms) {
     if (ms < 0) ms = 0;
     this.timeout = ms;
   }
@@ -1605,12 +1868,12 @@ class UnetSocket {
   }
 
   /**
-   * Receives a datagram sent to the local node and the bound protocol number. If the socket is unbound, 
+   * Receives a datagram sent to the local node and the bound protocol number. If the socket is unbound,
    * then datagrams with all unreserved protocols are received. Any broadcast datagrams are also received.
-   * 
+   *
    * @returns {Promise<?DatagramNtf>} - datagram received by the socket
    */
-  async receive() { 
+  async receive() {
     if (this.gw == null) return null;
     return await this.gw.receive(msg => {
       if (msg.__clazz__ != DatagramNtf.__clazz__ && msg.__clazz__ != RxFrameNtf.__clazz__ ) return false;
@@ -1631,31 +1894,34 @@ 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) {
+  async agentForService(svc, caching=true) {
     if (this.gw == null) return null;
-    return await this.gw.agentForService(svc);
+    return await this.gw.agentForService(svc, caching);
   }
 
   /**
-   * 
+   *
    * @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) {
+  async agentsForService(svc, caching=true) {
     if (this.gw == null) return null;
-    return await this.gw.agentsForService(svc);
+    return await this.gw.agentsForService(svc, caching``);
   }
 
   /**
    * 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) {
+  agent(name, caching=true) {
     if (this.gw == null) return null;
-    return this.gw.agent(name);
+    return this.gw.agent(name, caching);
   }
 
   /**
@@ -1663,7 +1929,7 @@ class UnetSocket {
    * @param {string} nodeName - name of the node to resolve
    * @returns {Promise<?number>} - address of the node, or null if unable to resolve
    */
-  async host(nodeName) { 
+  async host(nodeName) {
     const arp = await this.agentForService(Services.ADDRESS_RESOLUTION);
     if (arp == null) return null;
     const req = new AddressResolutionReq(nodeName);
@@ -1675,4 +1941,4 @@ class UnetSocket {
   }
 }
 
-export { AgentID, Gateway, Message, MessageClass, Performative, Protocol, Services, UnetMessages, UnetSocket };
+export { AgentID, CachingAgentID, CachingGateway as Gateway, Message, MessageClass, Performative, Protocol, Services, UnetMessages, UnetSocket, toGps, toLocal };