@indra.ai/deva 1.54.10 → 1.55.0

package/config/index.js

@@ -17,6 +17,9 @@ import msgs from './msgs.json' with {type:'json'};
 export default {
 	cmdChr: '/',
 	askChr: '#',
+	timeout: {
+		ask: 30000
+	},
 	container: {
 		begin: '::BEGIN',
 		end: '::END',

package/config/msgs.json

@@ -18,6 +18,8 @@
 		"nodata": "⛔️ NO DATA PROVIDED",
 		"nokey": "⛔️ NO KEY PROVIDED",
 		"invalidkey": "⛔️ INVALID KEY PROVIDED",
+		"asktimeout": "⛔️ ASK TIMEOUT",
+		"noask": "⛔️ NO ASK PROVIDED",
 		"method_not_found": "⛔️ METHOD NOT FOUND",
 		"help_not_found": "⛔️ HELP NOT FOUND",
 		"invalid_agent": "⛔️ Agent Hash Invalid",

package/index.js

@@ -19,6 +19,8 @@ class Deva {
     this._info = opts.info || false; // the deva information from the package file.
     this._config = opts.config || {}; // local Config Object
     this._config.ready_hash = config.ready_hash; // items to hash at ready
+    if (!this._config.timeout) this._config.timeout = config.timeout; // add timeout values to _config.
+    
     this._agent = opts.agent || false; // Agent profile object
     this._client = {}; // this will be set on init.
     this._active = false; // the active/birth date.
@@ -67,6 +69,9 @@ class Deva {
     this._uid = config.uid; // set the uid options
 
     this._events = config.events; // set the core system events
+    this._bound = new Map(); // evt -> wrapper registered on the shared bus
+    this._pending = new Set(); // pending asks: {evt, handler, timer}
+    
     this._feature = config.feature; // set the feature from config data.
     this._features = config.features; // set the features from config data.
 
@@ -179,10 +184,10 @@ class Deva {
         }
 
         // set the assigned listeners for the agent.
-        for (let listener in this.listeners) { // loop over the liteners
-          this.events.on(listener, packet => { // set the event listener
-            return this.listeners[listener](packet); // return the listener function
-          })
+        for (let listener in this.listeners) { // loop over the listeners
+          const handler = packet => this.listeners[listener](packet);
+          this._bound.set(listener, handler);
+          this.events.on(listener, handler);
         }
         return resolve(); // resolve the function after everything is done.
       }
@@ -192,8 +197,41 @@ class Deva {
     });
   }
 
+  /**************
+  func: _removeListeners
+  params: none
+  describe:
+    Remove listeners will take the this.lisners objects and remove the appropriate
+    listener values for the event bus.
+  ***************/
+  _removeListeners() {
+    if (!this.events || !this.listeners) return;
+    for (const evt in this.listeners) {
+      const handler = this._bound.get(evt);
+      if (handler) this.ignore(evt, handler); // ignore() already calls events.removeListener
+    }
+    this._bound.clear();
+    return this._clearPending(); // pending asks go in the same pass
+  }
+
+  /**************
+  func: _clearPending
+  params: none
+  describe:
+    Clears the timer and removes the listener for every pending ask so a
+    shutdown leaves nothing behind on the shared event bus.
+  ***************/
+  _clearPending() {
+    if (!this._pending) return;
+    for (const pending of this._pending) {
+      clearTimeout(pending.timer);
+      if (this.events) this.ignore(pending.evt, pending.handler);
+    }
+    this._pending.clear();
+  }
+  
   // Some elements will inherit the data of the parent. this object will loop over
-  // any children data that theis deva has and assign the inherited information.
+  // any children data that this deva has and assign the inherited information.
   /**************
   func: _assignInherit
   params: none
@@ -339,7 +377,8 @@ class Deva {
 
     if (clear) {
       this.state('loop', `${key}:clear:${data.id.uid}`);
-      for (let item of config.invoke.exit.clear) {
+      for (let item of clear) {
+        if (item === 'listeners') this._removeListeners();
         this[item] = false;
       }      
     }
@@ -693,9 +732,9 @@ class Deva {
     this.action('listen', evt);
     this.intent('good', `listen:${evt}`);
     this.listeners[evt] = callback;
-    return this.events.on(evt, packet => {
-      return this.listeners[evt](packet);
-    });
+    const handler = packet => this.listeners[evt](packet);
+    this._bound.set(evt, handler);
+    return this.events.on(evt, handler);    
   }
 
   /**************
@@ -821,14 +860,51 @@ class Deva {
           this.action('ask', `${key}:${id.uid}`);
           this.intent('good', `ask:${key}:${id.uid}`);
           this.once(`${key}:ask:${packet.id.uid}`, answer => {
-            this.action('talk', `${this._events.ask}:${id.uid}`);
-            this.intent('good', `${this._events.ask}:${id.uid}`);
-            this.talk(this._events.ask, this.lib.copy(answer));
-            this.action('return', `finish:${key}:ask:${id.uid}`);
-            this.intent('good', `finish:${method}:${id.uid}`);
-            return this.finish(answer, resolve); // if:isAsk resolve the answer from the call
+            const evt = `${key}:ask:${packet.id.uid}`; // the once event keyed to this packet.
+            const pending = {evt, handler: false, timer: false}; // tracked so shutdown can clean up.
+            
+            // single place to release the listener, the timer, and the pending record.
+            const release = () => {
+              clearTimeout(pending.timer);
+              this._pending.delete(pending);
+              if (this.events) this.ignore(evt, pending.handler);
+            };
+            
+            pending.handler = answer => {
+              clearTimeout(pending.timer); // an answer arrived so cancel the timeout.
+              this._pending.delete(pending);
+              this.action('talk', `${this._events.ask}:${id.uid}`);
+              this.intent('good', `${this._events.ask}:${id.uid}`);
+              this.talk(this._events.ask, this.lib.copy(answer));
+              this.action('return', `finish:${key}:ask:${id.uid}`);
+              this.intent('good', `finish:${method}:${id.uid}`);
+              return this.finish(answer, resolve); // if:isAsk resolve the answer from the call
+            };
+
+            this._pending.add(pending);
+            this.once(evt, pending.handler);
+
+            // timeout so a silent Deva cannot hang the caller. 0 disables it.
+            const wait = this._config.timeout.ask;
+            if (wait > 0) {
+              pending.timer = setTimeout(() => {
+                if (!this._active) return; // shutdown already cleaned up.
+                release();
+                this.state('abort', `${key}:${method}:${id.uid}`);
+                this.intent('bad', `ask:${key}:${id.uid}`);
+                return resolve(this._messages.asktimeout);
+              }, wait);
+            }
+            
+            // talk returns false when nobody is listening so fail fast instead of waiting.
+            const heard = this.talk(`${key}:ask`, this.lib.copy(packet));
+            if (!heard) {
+              release();
+              this.state('invalid', `${key}:${method}:${id.uid}`);
+              this.intent('bad', `ask:${key}:${id.uid}`);
+              return resolve(this._messages.noask);
+            }
           });
-          this.talk(`${key}:ask`, this.lib.copy(packet));
         }
         else { // else: answer the question locally
           this.state('answer', `${method}:${id.uid}`); //set the answer state to the method

package/package.json

@@ -1,7 +1,7 @@
 {
   "id": "23221940810208468106",
   "name": "@indra.ai/deva",
-  "version": "1.54.10",
+  "version": "1.55.0",
   "description": "Deva Core a Vedic-inspired Event Based Context Aware Feature, Zone, Action, and State Machine integrated Artificial Intelligence Framework",
   "main": "index.js",
   "license": "VLA:23221940810208468106 LICENSE.md",