@indra.ai/deva 1.1.39 → 1.1.40

package/index.js

@@ -16,10 +16,10 @@ class Deva {
     this._security = false;                             // inherited Security features.
     this._support = false;                              // inherited Support features.
     this._services = false;                             // inherited Service features.
-    this._assistant = false;                            // inherited Assistant features.
     this._business = false;                             // inherited Business features.
     this._development = false;                          // inherited Business features.
     this._legal = false;                                // inherited Legal features.
+    this._story = false;                            // inherited Assistant features.
     this.events = opts.events || new EventEmitter({});  // Event Bus
     this.lib = opts.lib || {};                          // used for loading library functions
     this.devas = opts.devas || {};                      // Devas which are loaded
@@ -30,8 +30,9 @@ class Deva {
     this.methods = opts.methods || {};                  // local Methods
     this.maxListeners = opts.maxListenners || 0;        // set the local maxListeners
 
+    // prevent overwriting existing functions and variables with same name
     for (var opt in opts) {
-      if (!this[opt]) this[opt] = opts[opt];            // set any remaining opts to this.
+      if (!this[opt] || !this[`_${opt}`]) this[opt] = opts[opt];
     }
 
     this.cmdChr = '/';                                  // the trigger for local commands
@@ -48,39 +49,35 @@ class Deva {
 
     this._state = 'offline';                            // current state of agent.
     this._states = {
-      ask: 'ask',
-      question: 'question',
-
-      offline: 'offline',
-      online: 'online',
-
-      init: 'initialize',
-      start: 'start',
-      enter: 'enter',
-      stop: 'stop',
-      exit: 'exit',
-      error: 'error',
-      load: 'load',
-      unload: 'unload',
-      uid: 'uid',
-      hash: 'hash',
-      cipher: 'cipher',
-      decipher: 'deciper',
-
-      invalid: 'invalid',
-      done: 'done',
-      error: 'error',
+      ask: `asked another Deva`,
+      question: `was asked a question`,
+      answer: `offered an answer`,
+
+      offline: `is Offline`,
+      online: `is Online`,
+
+      init: `Initialize`,
+      start: `start your journey`,
+      enter: `enter deva.world`,
+      stop: `stop what you are doing`,
+      exit: 'exit deva.world',
+      load: 'load Deva',
+      unload: 'unload Deva',
+
+      invalid: 'State Invalid',
+      done: 'State Done',
+      error: 'State Error',
     };                                  // states object
 
     this._zone = false;                            // current state of agent.
     this._zones = {
-      deva: 'deva.world',
+      deva: 'Deva Zone',
       config: 'Configuration Zone',
-      features: 'Features Zone',
+      features: 'Feature Zone',
       idle: 'Idle Zone',
       train: 'Training Zone',
       work: 'Working Zone',
-      invalid: 'Invalid Zone',
+      invalid: 'Invalid Invalid',
       done: 'Done Zone',
       error: 'Error Zone',
     };                                  // states object
@@ -90,122 +87,125 @@ class Deva {
       wait: 'wait',
       question: 'question',
       question_ask: 'question:ask',
-      question_ask_answer: 'question:ask:answer',
+      question_ask_answer: 'returned with an answer',
       question_cmd: 'question:cmd',
       question_method: 'question:method',
-      question_talk: 'quesiton:talk',
+      question_talk: 'question:talk',
       question_hash: 'question:hash',
       question_answer: 'question:answer',
-      question_done: 'quesiton:done',
+      question_done: 'question:done',
       answer: 'answer',
-      answer_talk: 'answer:talk',
-      ask: 'ask',
-      ask_answer: 'ask:answer',
-      security: '#security',
-      Security: '@SECURITY',
-      support: '#support',
-      Support: '@SUPPORT',
-      systems: '#systems',
-      Systems: '@SYSTEMS',
-      services: '#services',
-      Services: '@SERVICES',
-      solutions: '#solutions',
-      Solutions: '@SOLUTIONS',
-      development: '#development',
-      Development: '@DEVELOPMENT',
-      business: '#business',
-      Business: '@Business',
-      legal: '#legal',
-      Legal: '@LEGAL',
-      assistant: '#assistant',
-      Assistant: '@ASSISTANT',
-      story: '#story',
-      Story: '@STORY',
-      mind: '#mind',
-      Mind: '@MIND',
-      client_data: 'client:data',
-      invalid: 'invalid',
-      error: 'error',
-      done: 'done',
+      answer_hash: 'hashing the answer',
+      answer_talk: 'sharing the answer',
+      ask: 'asking',
+      ask_answer: 'answering',
+      security: 'security',
+      Security: 'Security Feature',
+      support: 'support',
+      Support: 'Support Feature',
+      systems: 'systems',
+      Systems: 'Systems Feature',
+      services: 'services',
+      Services: 'Services Feature',
+      solutions: 'solutions',
+      Solutions: 'Solutions Feature',
+      development: 'development',
+      Development: 'Development Feature',
+      business: 'business',
+      Business: 'Business Feature',
+      legal: 'legal',
+      Legal: 'Legal Feature',
+      assistant: 'assistant',
+      Assistant: 'Assistant Feature',
+      story: 'story',
+      Story: 'Story Feature',
+      mind: 'mind',
+      Mind: 'Mind Feature',
+      client_data: 'Client Data',
+      invalid: 'Actin Invalid',
+      error: 'Action Error',
+      done: 'Action Done',
     }
 
     this._feature = false;
     this._features = {
       security: 'security',
-      Security: 'SECURITY FEATURE',
+      Security: 'Security Feature',
       support: 'support',
-      Support: 'SUPPORT FEATURE',
+      Support: 'Support Feature',
       services: 'services',
-      Services: 'SERVICES FEATURE',
+      Services: 'Servicees Feature',
       solutions: 'solutions',
-      Solutions: 'SOLUTIONS FEATURE',
+      Solutions: 'Solutions Feature',
       systems: 'systems',
-      Systems: 'SYSTEMS FEATURE',
+      Systems: 'Systems Feature',
       development: 'development',
-      Development: 'DEVELOPMENT FEATURE',
+      Development: 'Development Feature',
       business: 'business',
-      Business: 'BUSINESS FEATURE',
+      Business: 'Business Feature',
       legal:'legal',
-      Legal:'LEGAL FEATURE',
+      Legal:'Legal Feature',
       assistant: 'assistant',
-      Assistant: 'ASSISTANT FEATURE',
+      Assistant: 'Assistant Feature',
       story: 'story',
-      Story: 'STORY FEATURE',
+      Story: 'Story Feature',
       mind: 'mind',
-      Mind: 'MIND FEATURE',
-      error: 'error',
-      done: 'done',
+      Mind: 'Mind Feature',
+      error: 'Feature Error',
+      done: 'Feature Done',
     };
 
     this._messages = {
       states: {
         offline: `${this._agent.profile.name} ${this._states.offline}`,
         online: `${this._agent.profile.name} ${this._states.online}`,
-        ask: `${this._agent.profile.name} ${this._state.ask}`,
-        question: `${this._agent.profile.name} ${this._states.quesiton}`,
+        ask: `😎 ${this._agent.profile.name} ${this._states.ask}`,
+        question: `🎙️ ${this._agent.profile.name} ${this._states.question}`,
+        answer: `🎟️  ${this._agent.profile.name} ${this._states.answer}`,
         offline: `${this._agent.profile.name} ${this._states.offline}`,
         online: `${this._agent.profile.name} ${this._states.online}`,
-        init: `${this._agent.profile.name} ${this._states.init}`,
-        start: `${this._agent.profile.name} ${this._states.start}`,
-        enter: `${this._agent.profile.name} ${this._states.enter}`,
-        stop: `${this._agent.profile.name} ${this._states.stop}`,
-        exit: `${this._agent.profile.name} ${this._states.exit}`,
-        load: `${this._agent.profile.name} ${this._states.load}`,
-        unload: `${this._agent.profile.name} ${this._states.unload}`,
+        init: `🚀 ${this._agent.profile.name} ${this._states.init}`,
+        start: `🎬 ${this._agent.profile.name} ${this._states.start}`,
+        enter: `📲 ${this._agent.profile.name} ${this._states.enter}`,
+        stop: `✋ ${this._agent.profile.name} ${this._states.stop}`,
+        exit: `🚪 ${this._agent.profile.name} ${this._states.exit}`,
+        load: `📫 ${this._agent.profile.name} ${this._states.load}`,
+        unload: `📭 ${this._agent.profile.name} ${this._states.unload}`,
         uid: `${this._agent.profile.name} ${this._states.uid}`,
         hash: `${this._agent.profile.name} ${this._states.hash}`,
         cipher: `${this._agent.profile.name} ${this._states.cipher}`,
         decipher: `${this._agent.profile.name} ${this._states.decipher}`,
-        invalid: `${this._agent.profile.name} ${this._states.invalid}`,
-        done: `${this._agent.profile.name} ${this._states.done}`,
-        error: `${this._states.error}`,
+        invalid: `⚠️ ${this._agent.profile.name} ${this._states.invalid}`,
+        done: `✅ ${this._agent.profile.name} ${this._states.done}`,
+        error: `❌ ${this._states.error}`,
       },
       zones: {
-        deva: `${this._agent.profile.name} enter ${this._zones.deva}`,
-        config: `${this._agent.profile.name} ${this._zones.config}`,
-        features: `${this._agent.profile.name} ${this._zones.features}`,
-        idle: `${this._agent.profile.name} ${this._zones.idle}`,
-        train: `${this._agent.profile.name} ${this._zones.train}`,
-        work: `${this._agent.profile.name} ${this._zones.work}`,
-        invalid: `${this._agent.profile.name} ${this._zones.invalid}`,
-        done: `${this._agent.profile.name} ${this._zones.done}`,
-        error: `${this._agent.profile.name} ${this._zones.error}`,
+        deva: `🎉 ${this._agent.profile.name} entered the ${this._zones.deva}`,
+        config: `💪 ${this._agent.profile.name} is in the ${this._zones.config}`,
+        features: `🍿 ${this._agent.profile.name} entered the ${this._zones.features}`,
+        idle: `🥱 ${this._agent.profile.name} is stuck in the ${this._zones.idle}`,
+        train: `👨‍🎓 ${this._agent.profile.name} is learning in the ${this._zones.train}`,
+        work: `😓 ${this._agent.profile.name} is handling things in the ${this._zones.work}`,
+        invalid: `⚠️ ${this._agent.profile.name} fell into the ${this._zones.invalid}`,
+        done: `✅ ${this._agent.profile.name} and here we are in the ${this._zones.done}`,
+        error: `❌ ${this._agent.profile.name} fell into the ${this._zones.error}`,
       },
       actions: {
-        wait: `${this._agent.profile.name} ${this._actions.wait}`,
-        question: `${this._agent.profile.name} ${this._actions.question}`,
-        question_ask: `${this._agent.profile.name} ${this._actions.question_ask}`,
-        question_ask_answer: `${this._agent.profile.name} ${this._actions.questoin_ask_answer}`,
-        question_cmd: `${this._agent.profile.name} ${this._actions.question_cmd}`,
-        question_method: `${this._agent.profile.name} ${this._actions.question_method}`,
-        question_talk: `${this._agent.profile.name} ${this._actions.question_talk}`,
-        question_hash: `${this._agent.profile.name} ${this._actions.question_hash}`,
-        question_answer: `${this._agent.profile.name} ${this._actions.question_answer}`,
-        question_done: `${this._agent.profile.name} ${this._actions.question_done}`,
-        answer: `${this._agent.profile.name} ${this._actions.answer}`,
-        answer_talk: `${this._agent.profile.name} ${this._actions.answer_talk}`,
-        ask: `${this._agent.profile.name} ${this._actions.ask}`,
-        ask_answer: `${this._agent.profile.name} ${this._actions.ask_answer}`,
+        wait: `😵‍💫 ${this._agent.profile.name} ${this._actions.wait}`,
+        question: `👀 ${this._agent.profile.name} ${this._actions.question}`,
+        question_ask: `👥 ${this._agent.profile.name} ${this._actions.question_ask}`,
+        question_ask_answer: `📣 ${this._agent.profile.name} ${this._actions.question_ask_answer}`,
+        question_cmd: `🎮 ${this._agent.profile.name} issued a command`,
+        question_method: `🏄‍♂️ ${this._agent.profile.name} ${this._actions.question_method}`,
+        question_talk: `📢 ${this._agent.profile.name} ${this._actions.question_talk}`,
+        question_hash: `#️⃣  ${this._agent.profile.name} is hashing a question`,
+        question_answer: `🎙️ ${this._agent.profile.name} ${this._actions.question_answer}`,
+        question_done: `👍 ${this._agent.profile.name} ${this._actions.question_done}`,
+        answer: `🎟️  ${this._agent.profile.name} shared the ${this._actions.answer}`,
+        answer_talk: `🎟️  ${this._agent.profile.name} is talking the ansnwer for anyone listening `,
+        ask: `👥 ${this._agent.profile.name} is asking`,
+        ask_answer: `🎟️  ${this._agent.profile.name} is answering the ask`,
+
         security: `${this._actions.security} is responding`,
         Security: `${this._actions.Security} is ready`,
         support: `${this._actions.support} is responding`,
@@ -228,37 +228,37 @@ class Deva {
         Story: `${this._actions.Story} is ready`,
         mind: `${this._actions.Mind} is responding`,
         Mind: `${this._actions.Mind} is ready`,
-        client_data: `${this._agent.profile.name} setting Client Data`,
+        client_data: `📂 ${this._agent.profile.name} setting Client Data`,
         invalid: `${this._actions.invalid}`,
-        done: `${this._actions.done}`,
+        done: `✅ ${this._actions.done}`,
         error: `${this._action.error}`,
       },
       features: {
         security: `${this._features.security} is protecting`,
-        Security: `${this._features.Security} is configuring`,
+        Security: `${this._features.Security} loading...`,
         support: `${this._features.support} is caring`,
-        Support: `${this._features.Support} is configuring`,
+        Support: `${this._features.Support} loading...`,
         services: `${this._features.services} is servicing`,
-        Services: `${this._features.Services} is configuring`,
+        Services: `${this._features.Services} loading...`,
         solutions: `${this._features.solutions} is solving`,
-        Solutions: `${this._features.Solutions} is configuring`,
+        Solutions: `${this._features.Solutions} loading...`,
         systems: `${this._features.systems} is mantaining`,
-        Systems: `${this._features.Systems} is configuring`,
+        Systems: `${this._features.Systems} loading...`,
         development: `${this._features.development} is developing`,
-        Development: `${this._features.Development} is working on ideas`,
+        Development: `${this._features.Development} loading...`,
         business: `${this._features.business} is successful`,
-        Business: `${this._features.Business} is configuring`,
+        Business: `${this._features.Business} loading...`,
         legal: `${this._features.legal} is upholding the law`,
-        Legal: `${this._features.Legal} is configuring`,
+        Legal: `${this._features.Legal} loading...`,
         assistant: `${this._features.assistant} is assisting`,
-        Assistant: `${this._features.Assistant} is configuring`,
+        Assistant: `${this._features.Assistant} loading...`,
         story: `${this._features.story} is creating`,
-        Story: `${this._features.Story} is configuring`,
+        Story: `${this._features.Story} loading...`,
         mind: `${this._features.story} is thinking and pondering`,
-        Mind: `${this._features.Mind} is configuring`,
-        invalid: this._features.invalid,
-        done: this._features.done,
-        error: this._features.error,
+        Mind: `${this._features.Mind} loading...`,
+        invalid: `⚠️ ${this._features.invalid}`,
+        done: `✅ ${this._features.done}`,
+        error: `❌ ${this._features.error}`,
       },
     };                                // messages object
   }
@@ -290,11 +290,12 @@ class Deva {
   ***************/
   Security() {
     this.feature('Security');
+    const _cl = this.client();
     try {
-      if (this._client.features.security) return this.Support();
+      if (!_cl.features.security) return this.Support();
       else {
         this.action('Security');
-        const {id, profile, features} = this._client;   // make a copy the clinet data.
+        const {id, profile, features} = _cl;            // make a copy the clinet data.
         const {security} = features;                    // make a copy the clinet data.
         this._security = {                              // set this_security with data
           id: this.uid(true),                           // uuid of the security feature
@@ -325,11 +326,12 @@ class Deva {
   ***************/
   Support() {
     this.feature('Support');                  // set state to support setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.support) return this.Services()
+      if (!_cl.features.support) return this.Services()
       else {
         this.action('Support');
-        const {id, features, profile} = this._client;        // set the local consts from client copy
+        const {id, features, profile} = _cl;            // set the local consts from client copy
         const {support} = features;                     // set support from features const
         this._support = {                               // set this_support with data
           id: this.uid(true),                           // uuid of the support feature
@@ -358,11 +360,12 @@ class Deva {
   ***************/
   Services() {
     this.feature('Services');                 // set state to security setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.services) return this.Systems();
+      if (!_cl.features.services) return this.Systems();
       else {
         this.action('Services')
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {services} = features;                    // set services from features const
         this._services = {                              // set this_services with data
           id: this.uid(true),                           // uuid of the services feature
@@ -391,11 +394,12 @@ class Deva {
   ***************/
   Systems() {
     this.feature('Systems');                  // set state to systems setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.systems) return this.Solutions();
+      if (!_cl.features.systems) return this.Solutions();
       else {
         this.action('Systems');
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {systems} = features;                     // set systems from features const
         this._systems = {                               // set this_systems with data
           id: this.uid(true),                           // uuid of the systems feature
@@ -425,11 +429,12 @@ class Deva {
   ***************/
   Solutions() {
     this.feature('Solutions');                // set state to solutions setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.solutions) return this.Development();
+      if (!_cl.features.solutions) return this.Development();
       else {
         this.action('Solutions');
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {solutions} = features;                   // set solutions from features const
         this._solutions = {                             // set this_solutions with data
           id: this.uid(true),                           // uuid of the solutions feature
@@ -458,11 +463,12 @@ class Deva {
   ***************/
   Development() {
     this.feature('Development');              // set state to development setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.development) return this.Business();
+      if (!_cl.features.development) return this.Business();
       else {
         this.action('Development');
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {development} = features;                 // set development from features const
         this._development = {                           // set this_development with data
           id: this.uid(true),                           // uuid of the development feature
@@ -491,11 +497,12 @@ class Deva {
   ***************/
   Business(client=false) {
     this.feature('Business');                 // set state to business setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.business) return this.Legal();
+      if (!_cl.features.business) return this.Legal();
       else {
         this.action('Business');
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {business} = features;                    // set business from features const
         this._business = {                              // set this_business with data
           id: this.uid(true),                           // uuid of the business feature
@@ -524,11 +531,12 @@ class Deva {
   ***************/
   Legal() {
     this.feature('Legal');                    // set state to legal setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.legal) this.Assistant();
+      if (!_cl.features.legal) this.Assistant();
       else {
         this.action('Legal');
-        const {id, features, profile} = this._client;   // set the local consts from client copy
+        const {id, features, profile} = _cl;   // set the local consts from client copy
         const {legal} = features;                       // set legal from features const
         this._legal = {                                 // set this_legal with data
           id: this.uid(true),                           // uuid of the legal feature
@@ -542,6 +550,8 @@ class Deva {
         return this.Assistant();
       }
     } catch (e) {
+      this.action('error');
+      this.feature('error');
       return this.error(e)                             // run error handling if an error is caught
     }
   }
@@ -555,11 +565,12 @@ class Deva {
   ***************/
   Assistant(client=false) {
     this.feature('Assistant');                 // set state to assistant setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.assistant) return this.Done();
+      if (!_cl.features.assistant) return this.Done();
       else {
         this.action('Assistant');
-        const {id, features, profile} = this._client;        // set the local consts from client copy
+        const {id, features, profile} = _cl;        // set the local consts from client copy
         const {assistant} = features;                    // set assistant from features const
         this._assistant = {                              // set this_assistant with data
           id: this.uid(true),                           // uuid of the assistant feature
@@ -573,6 +584,8 @@ class Deva {
         return this.Story();
       }
     } catch (e) {
+      this.action('error');
+      this.feature('error');
       return this.error(e)                             // run error handling if an error is caught
     }
   }
@@ -586,6 +599,7 @@ class Deva {
   ***************/
   Story(client=false) {
     this.feature('Story');                 // set state to story setting
+    const _cl = this.client();
     try {
       if (!this._client.features.story) return this.Mind();
       else {
@@ -619,11 +633,12 @@ class Deva {
   ***************/
   Mind(client=false) {
     this.feature('Mind');                 // set state to story setting
+    const _cl = this.client();
     try {
-      if (!this._client.features.mind) return this.Done();
+      if (!_cl.features.mind) return this.Done();
       else {
         this.action('Mind');
-        const {id, features, profile} = this._client;       // set the local consts from client copy
+        const {id, features, profile} = _cl;       // set the local consts from client copy
         const {mind} = features;                           // set mind from features const
         this._mind = {                                     // set this_mind with data
           id: this.uid(true),                               // uuid of the mind feature
@@ -652,6 +667,7 @@ class Deva {
     return new Promise((resolve, reject) => {
       try {
         delete this._client.features;               // delete the features key when done.
+        this.action('done');                 // set state to assistant setting
         this.feature('done');                 // set state to assistant setting
         return resolve();
       } catch (e) {
@@ -769,8 +785,8 @@ class Deva {
   ***************/
   _methodNotFound(packet) {
     packet.a = {
-      agent: this._agent || false,
-      client: this._client || false,
+      agent: this.agent() || false,
+      client: this.client() || false,
       text: `${this._messages.method_not_found}`,
       meta: {
         key: this._agent.key,
@@ -778,7 +794,7 @@ class Deva {
       },
       created: Date.now(),
     };
-    this.state('method_not_found', packet);
+    this.state('method_not_found');
     return packet;
   }
 
@@ -843,127 +859,6 @@ class Deva {
     return this.events.removeListener(evt, callback);
   }
 
-  /**************
-  func: ask
-  params: packet
-  describe:
-    The ask function gives each agent the ability to ask question to other agents
-    in the system. When a question is asked the Agent with the question if it
-    detect an ask event it will trigger. Then if an Agent with the matching ask
-    event is listening they will respond. The question function uses this to
-    create integrated communication between itself and other Deva in it's library.
-
-    It can also be used in a custom manner to broadcast ask events inside other coe aswell.
-
-    When the talk has an answer it will respond with a talk event that has the packet id
-    so the event is specific to the talk.
-  ***************/
-  ask(packet) {
-    if (!this._active) return Promise.resolve(this._messages.states.offline);
-    this.action('question', packet);
-
-    packet.a = {
-      agent: this._agent || false,
-      client: this._client || false,
-      meta: {
-        key: this._agent.key,
-        method: packet.q.meta.method,
-        params: packet.q.meta.params,
-      },
-      text: false,
-      html: false,
-      data: false,
-      created: Date.now(),
-    };
-
-    try {
-      if (this.methods[packet.q.meta.method] !== 'function') {
-        return setImmediate(() => {
-          this.action('ask_invalid')
-          packet.a.text = `INVALID METHOD (${packet.q.meta.method})`;
-          this.talk(`${this._agent.key}:ask:${packet.id}`, packet);
-        });
-      }
-
-      // The method is parsed and depending on what method is asked for it returns
-      // the response based on the passed through packet.
-      this.methods[packet.q.meta.method](packet).then(result => {
-        if (typeof result === 'object') {
-          packet.a.text = result.text || false;
-          packet.a.html = result.html || false;
-          packet.a.data = result.data || false;
-        }
-        else {
-          packet.a.text = result;
-        }
-        this.action('ask_answer', packet);
-        this.talk(`${this._agent.key}:ask:${packet.id}`, packet);
-      }).catch(err => {
-        this.action('error', err);
-        this.talk(`${this._agent.key}:ask:${packet.id}`, {error:err.toString()});
-        return this.error(err, packet);
-      })
-    }
-    catch (e) {
-      this.action('error', err);
-      this.talk(`${this._agent.key}:ask:${packet.id}`, {error:e.toString()});
-      return this.error(e, packet)
-    }
-    // now when we ask the meta params[0] should be the method
-  }
-
-  answer(packet, resolve, reject) {
-    this.action('answer', packet);        // set the question answer state
-    // check if method exists and is of type function
-    const {method,params} = packet.q.meta;
-    const isMethod = this.methods[method] && typeof this.methods[method] == 'function';
-    if (!isMethod) {
-      this.action('invalid')
-      return resolve(this._methodNotFound(packet)); // resolve method not found if check if check fails
-    }
-    // Call the local method to process the question based the extracted parameters
-    return this.methods[method](packet).then(result => {
-      // check the result for the text, html, and data object.
-      // this is for when answers are returned from nested Devas.
-      const text = typeof result === 'object' ? result.text : result;
-      const html = typeof result === 'object' ? result.html : result;
-      // if the data passed is NOT an object it will FALSE
-      const data = typeof result === 'object' ? result.data : false;
-
-
-      packet.a = {                                  // setup the packet.a container
-        agent: this._agent || false,                // set the agent who answered the question
-        client: this._client || false,              // set the client asking the question
-        meta: {                                     // setup the answer meta container
-          key: this._agent.key,                     // set the agent key inot the meta
-          method,                                   // set the method into the meta
-          params,                                   // set the params into the meta
-        },
-        text,                                       // set answer text
-        html,
-        data,
-        created: Date.now(),
-      };
-
-      // create a hash for the answer and insert into answer meta.
-      this.action('hash_answer');
-      packet.a.meta.hash = this.hash(JSON.stringify(packet.a));
-      // create a hash for entire packet and insert into packet
-      // hash the entire packet.
-      this.action('hash_packet');
-      packet.hash = this.hash(JSON.stringify(packet));
-
-      this.action('answer_talk');
-      this.talk(`${this._agent.key}:answer`, packet);        // set the question answer state
-
-      this.action('done');
-      return resolve(packet);                                // resolve the packet to the caller.
-    }).catch(err => {                               // catch any errors in the method
-      this.action('error', err);
-      return this.error(err, packet, reject);       // return this.error with err, packet, reject
-    });
-  }
-
   /**************
   func: question
   example: this.question('#*agent.key *method* *text*')
@@ -978,6 +873,7 @@ class Deva {
     if (!this._active) return Promise.resolve(this._messages.states.offline);
     const id = this.uid();                                // generate a unique id for transport.
     const t_split = TEXT.split(' ');                      // split the text on spaces to get words.
+    this.state('question');
     this.action('question', id);
 
     // check to see if the string is an #ask string to talk to the other Deva.
@@ -991,8 +887,8 @@ class Deva {
     const data = DATA;                                    // set the DATA to data
     const packet = {                                      // create the base q/a packet
       id,                                                 // set the id into packet
-      q: {},                                              // create empty q object in packet
-      a: {},                                              // create empty a object in packet
+      q: false,                                              // create empty q object in packet
+      a: false,                                              // create empty a object in packet
       created: Date.now(),                                // timestamp the packet
     };
 
@@ -1009,6 +905,7 @@ class Deva {
       let _action = 'question_method'
       try {                                               // try to answer the question
         if (isAsk) {                                      // determine if hte question isAsk
+          _action = 'question_ask';
           key = t_split[0].substring(1);                  // if:isAsksplit the agent key and remove first command character
           //if:isAsk use text split index 1 as the parameter block
           params = t_split[1] ? t_split[1].split(':') : false;
@@ -1023,12 +920,12 @@ class Deva {
           text = t_split.slice(1).join(' ').trim();       // if:isCmd rejoin the string on the space after removing first index
         }
         else {
-          this.action('question_method');
         }
 
         packet.q = {                                      // build packet.q container
-            agent: this._agent || false,                  // set the agent
-            client: this._client || false,                // set the client
+            id: this.uid(),
+            agent: this.agent() || false,                  // set the agent
+            client: this.client() || false,                // set the client
             meta: {                                       // build the meta container
               key,                                        // set the key variable
               orig,                                       // set orig text to track chances
@@ -1044,18 +941,20 @@ class Deva {
         this.action('question_hash');                      // set the has question state
         packet.q.meta.hash = this.hash(JSON.stringify(packet.q));
 
+        this.action(_action);
+        this.talk('devacore:question', this.copy(packet));         // global question event make sure to copy data.
 
         if (isAsk) {                                      // isAsk check if the question isAsk and talk
-          this.action('question_ask');
-          this.talk(`${key}:ask`, packet);                // if:isAsk talk the event to theother Deva
+          this.state('ask');
           // if: isAsk wait for the once event which is key'd to the packet ID for specified responses
+          this.talk(`${key}:ask`, this.copy(packet));
           this.once(`${key}:ask:${packet.id}`, answer => {
             this.action('question_ask_answer');
             return resolve(answer);                       // if:isAsk resolve the answer from the call
           });
         }
         else {                                            // else: answer tue question locally
-          this.action(_action);
+          this.action('ask_answer');
           return this.answer(packet, resolve, reject);
         }
       }
@@ -1066,6 +965,146 @@ class Deva {
     });
   }
 
+  /**************
+  func: answer
+  params:
+    - packet
+    - resolve
+    - reject
+  describe:
+    The answer function is called from the question fuction to return an answer
+    from the agent from the pre-determined method.
+  ***************/
+  answer(packet, resolve, reject) {
+    if (!this._active) return Promise.resolve(this._messages.states.offline);
+
+    this.state('answer');
+    // check if method exists and is of type function
+    const {method,params} = packet.q.meta;
+    const isMethod = this.methods[method] && typeof this.methods[method] == 'function';
+    if (!isMethod) {
+      this.action('invalid')
+      return resolve(this._methodNotFound(packet)); // resolve method not found if check if check fails
+    }
+    // Call the local method to process the question based the extracted parameters
+    return this.methods[method](packet).then(result => {
+      this.action('answer');
+      // check the result for the text, html, and data object.
+      // this is for when answers are returned from nested Devas.
+      const text = typeof result === 'object' ? result.text : result;
+      const html = typeof result === 'object' ? result.html : result;
+      // if the data passed is NOT an object it will FALSE
+      const data = typeof result === 'object' ? result.data : false;
+
+      const agent = this.agent() || false;
+      const client = this.client() || false;
+      packet.a = {                                  // setup the packet.a container
+        id: this.uid(),
+        agent,                                      // set the agent who answered the question
+        client,                                     // set the client asking the question
+        meta: {                                     // setup the answer meta container
+          key: agent.key,                           // set the agent key inot the meta
+          method,                                   // set the method into the meta
+          params,                                   // set the params into the meta
+        },
+        text,                                       // set answer text
+        html,                                       // set the answer html
+        data,                                       // set the answer data
+        created: Date.now(),
+      };
+
+      // create a hash for the answer and insert into answer meta.
+      this.action('answer_hash');
+      packet.a.meta.hash = this.hash(JSON.stringify(packet.a));
+
+      this.action('packet_hash');
+      packet.hash = this.hash(JSON.stringify(packet));     // hash the entire packet.
+
+
+      this.action('answer_talk');
+      this.talk('devacore:answer', this.copy(packet));             // talk the answer with a copy of the data
+
+      return resolve(packet);                             // resolve the packet to the caller.
+    }).catch(err => {                                     // catch any errors in the method
+      this.action('error');
+      return this.error(err, packet, reject);             // return this.error with err, packet, reject
+    });
+  }
+
+  /**************
+  func: ask
+  params: packet
+  describe:
+    The ask function gives each agent the ability to ask question to other agents
+    in the system. When a question is asked the Agent with the question if it
+    detect an ask event it will trigger. Then if an Agent with the matching ask
+    event is listening they will respond. The question function uses this to
+    create integrated communication between itself and other Deva in it's library.
+
+    It can also be used in a custom manner to broadcast ask events inside other coe aswell.
+
+    When the talk has an answer it will respond with a talk event that has the packet id
+    so the event is specific to the talk.
+  ***************/
+  ask(packet) {
+    if (!this._active) return Promise.resolve(this._messages.states.offline);
+    this.state('ask');
+    this.action('ask');
+
+    const agent = this.agent() || false;
+    const client = this.client() || false;
+    // build the answer packet from this model
+    packet.a = {
+      agent,
+      client,
+      meta: {
+        key: agent.key,
+        method: packet.q.meta.method,
+        params: packet.q.meta.params,
+      },
+      text: false,
+      html: false,
+      data: false,
+      created: Date.now(),
+    };
+
+    try {
+      if (typeof this.methods[packet.q.meta.method] !== 'function') {
+        return setImmediate(() => {
+          this.action('invalid')
+          packet.a.text = `INVALID METHOD (${packet.q.meta.method})`;
+          this.talk(`${this._agent.key}:ask:${packet.id}`, packet);
+        });
+      }
+
+      // The method is parsed and depending on what method is asked for it returns
+      // the response based on the passed through packet.
+      this.methods[packet.q.meta.method](packet).then(result => {
+        if (typeof result === 'object') {
+          packet.a.text = result.text || false;
+          packet.a.html = result.html || false;
+          packet.a.data = result.data || false;
+        }
+        else {
+          packet.a.text = result;
+        }
+        this.action('ask_answer');
+        this.talk(`${this._agent.key}:ask:${packet.id}`, this.copy(packet));
+      }).catch(err => {
+        this.action('error');
+        this.talk(`${this._agent.key}:ask:${packet.id}`, {error:err.toString()});
+        return this.error(err, packet);
+      })
+    }
+    catch (e) {
+      this.action('error');
+      this.talk(`${this._agent.key}:ask:${packet.id}`, {error:e.toString()});
+      return this.error(e, packet)
+    }
+    // now when we ask the meta params[0] should be the method
+  }
+
+
   /**************
   func: init
   params: client - the client data to use that is provided by the clients.
@@ -1083,14 +1122,15 @@ class Deva {
   ***************/
   init(client) {
     const _data = {
-      id: this.uid(),
-      key: 'init',
+      id: this.uid(true),
+      key: 'return',
       value: 'init',
       agent: this._agent,
       client: this.copy(client),
       text: this._messages.states.start,
       created: Date.now(),
     }
+    _data.hash = this.hash(JSON.stringify(_data));
 
     // set client
     this._active = Date.now();
@@ -1110,8 +1150,6 @@ class Deva {
         return this.Security();
       }).then(() => {
         this.zone('deva');
-
-        _data.hash = this.hash(JSON.stringify(_data));
         const hasOnInit = this.onInit && typeof this.onInit === 'function';
         return hasOnInit ? this.onInit(_data) : this.start(_data)
       }).catch(err => {
@@ -1120,34 +1158,6 @@ class Deva {
     });
   }
 
-  /**************
-  func: error
-  params:
-    - err: The error to process
-    - data: Any additional data associated with the error
-    - reject: An associated promise reject if the caller requires.
-  describe:
-    The erro function rpovides the consistent error manage of the system.
-  usage: this.error(err, data, reject);
-  ***************/
-  error(err,data=false,reject=false) {
-    // check fo rthe custom onError function in the agent.
-    console.log('\n::BEGIN:ERROR\n');
-    console.log(err);
-    console.log('\n::END:ERROR\n');
-    if (data) {
-      console.log('::::::');
-      console.log('\n::BEGIN:DATA\n');
-      console.log(JSON.stringify(data, null, 2));
-      console.log('\n::END:DATA\n');
-    }
-
-    if (this.onError && typeof this.onError === 'function') return this.onError(err, data, reject);
-    else {
-      return reject ? reject(err) : err;
-    }
-  }
-
   /**************
   func: start
   params:
@@ -1161,18 +1171,59 @@ class Deva {
   start(data=false) {
     this.state('start');
     if (!this._active) return Promise.resolve(this._messages.states.offline);
-    const _data = {
-      id: this.uid(),
-      key: 'start',
-      value: 'start',
-      agent: this._agent,
-      client: data.client || this._client,
-      text: this._messages.states.start,
-      created: Date.now(),
+    data.value = 'start';
+    delete data.hash;
+    data.hash = this.hash(JSON.stringify(data));
+
+    if (this.info) {
+      const _info = JSON.stringify(this.info, null, 2).replace(/\{/g, '::BEGIN:INFO')
+                        .replace(/\"|\,/g, '').replace(/\}/g, '::END:INFO').trim()
+      this.prompt(_info);
     }
-    _data.hash = this.hash(JSON.stringify(_data));
-    const hasOnStart = this.onStart && typeof this.onStart === 'function';
-    return hasOnStart ? this.onStart(_data) : this.enter(_data)
+    const hasOnStart = this.onStart && typeof this.onStart === 'function' ? true : false;
+    return hasOnStart ? this.onStart(data) : this.enter(data)
+  }
+
+  /**************
+  func: enter
+  params:
+    - msg: hte message from the caller incase need to use in calls
+  describe:
+    The ener function will check the actie status of the Deva and set it to
+    offline or enter.
+
+    If the Deva is offline it will return the offline message.
+  usage: this.enter('msg')
+  ***************/
+  enter(data=false) {
+    this.state('enter');
+    if (!this._active) return Promise.resolve(this._messages.states.offline);
+    data.value = 'enter';
+    delete data.hash;
+    data.hash = this.hash(JSON.stringify(data));
+    const hasOnEnter = this.onEnter && typeof this.onEnter === 'function' ? true : false;
+    return hasOnEnter ? this.onEnter(_data) : this.done(data)
+  }
+
+  /**************
+  func: done
+  params:
+  - msg: hte message from the caller incase need to use in calls
+  describe:
+    When the done function is triggered the system will also set the state
+    of hte Deva to done.
+
+    If the deva is offline it will return the offline message.
+  usage: this.done('msg')
+  ***************/
+  done(data=false) {
+    this.state('done');
+    if (!this._active) return Promise.resolve(this._messages.states.offline);
+    data.value = 'done';
+    delete data.hash;
+    data.hash = this.hash(JSON.stringify(data));
+    const hasOnDone = this.onDone && typeof this.onDone === 'function' ? true : false;
+    return hasOnDone ? this.onDone(data) : Promise.resolve(data);
   }
 
   /**************
@@ -1188,15 +1239,15 @@ class Deva {
   usage:
     this.stop('msg')
   ***************/
-  stop(data=false) {
+  stop() {
     this.state('stop');
     if (!this._active) return Promise.resolve(this._messages.states.offline);
     const _data = {
-      id: this.uid(),
-      key: 'stop',
+      id: this.uid(true),
+      key: 'return',
       value: 'stop',
-      agent: this._agent,
-      client: data.client || this._client,
+      agent: this.agent(),
+      client: this.client(),
       text: this._messages.states.stop,
       created: Date.now(),
     }
@@ -1205,33 +1256,6 @@ class Deva {
     return hasOnStop ? this.onStop(_data) : this.exit(_data)
   }
 
-  /**************
-  func: enter
-  params:
-    - msg: hte message from the caller incase need to use in calls
-  describe:
-    The ener function will check the actie status of the Deva and set it to
-    offline or enter.
-
-    If the Deva is offline it will return the offline message.
-  usage: this.enter('msg')
-  ***************/
-  enter(data=false) {
-    this.state('enter');
-    if (!this._active) return Promise.resolve(this._messages.states.offline);
-    const _data = {
-      id: this.uid(),
-      type: 'enter',
-      value: 'enter',
-      agent: this._agent,
-      client: data.client || this._client,
-      text: this._messages.states.enter,
-      created: Date.now(),
-    }
-    _data.hash = this.hash(JSON.stringify(_data));
-    const hasOnEnter = this.onEnter && typeof this.onEnter === 'function';
-    return hasOnEnter ? this.onEnter(_data) : this.done(_data)
-  }
 
   /**************
   func: exit
@@ -1249,50 +1273,27 @@ class Deva {
   ***************/
   exit(data=false) {
     this.state('exit');
-    if (!this._active) return Promise.resolve(this._messages.states.offline);
     this._active = false;
-    const _data = {
-      id: this.uid(),
-      key: 'exit',
-      value: 'exit',
-      agent: this._agent,
-      client: this._client || this._client,
-      text: this._messages.states.exit,
-      created: Date.now(),
-    }
-    _data.hash = this.hash(JSON.stringify(_data));
-    const hasOnExit = this.onExit && typeof this.onExit === 'function';
-    return hasOnExit ? this.onExit(_data) : Promise.resolve(_data)
-  }
+    data.value = 'exit';
+    delete data.hash;
+    data.hash = this.hash(JSON.stringify(data));
 
-  /**************
-  func: done
-  params:
-  - msg: hte message from the caller incase need to use in calls
-  describe:
-    When the done function is triggered the system will also set the state
-    of hte Deva to done.
+    // clear memory
+    this._active = false;
+    this._client = false;
+    this._security = false;
+    this._support = false;
+    this._services = false;
+    this._business = false;
+    this._development = false;
+    this._legal = false;
+    this._story = false;
 
-    If the deva is offline it will return the offline message.
-  usage: this.done('msg')
-  ***************/
-  done(data=false) {
-    this.state('done');
-    if (!this._active) return Promise.resolve(this._messages.states.offline);
-    const _data = {
-      id: this.uid(),
-      key: 'done',
-      value: 'done',
-      agent: this._agent,
-      client: data.client || this._client,
-      text: this._messages.states.exit,
-      created: Date.now(),
-    }
-    _data.hash = this.hash(JSON.stringify(_data));
-    const hasOnDone = this.onDone && typeof this.onDone === 'function';
-    return hasOnDone ? this.onDone(_data) : Promise.resolve(_data)
+    const hasOnExit = this.onExit && typeof this.onExit === 'function';
+    return hasOnExit ? this.onExit(data) : Promise.resolve(data)
   }
 
+
   ////////////////////////////
 
   /**************
@@ -1301,22 +1302,22 @@ class Deva {
     - st: The state flag to set for the Deva that matches to this._states
   describe
   ***************/
-  state(state, data=false) {
+  state(state) {
     try {
       if (!this._states[state]) return;
       this._state = state;
       const text = this._messages.states[state];
       const _data = {
-        id: this.uid(),
+        id: this.uid(true),
         key: 'state',
         value: state,
-        agent: this._agent,
+        agent: this.agent(),
+        client: this.client(),
         text,
-        data,
         created: Date.now(),
       };
       _data.hash = this.hash(JSON.stringify(_data));
-      this.talk('state', _data);
+      this.talk('devacore:state', this.copy(_data));
     } catch (e) {
       return this.error(e);
     }
@@ -1334,7 +1335,7 @@ class Deva {
       this._zone = zone;
       const text = this._messages.zones[zone];
       const _data = {
-        id: this.uid(),
+        id: this.uid(true),
         key: 'zone',
         value: zone,
         agent: this._agent,
@@ -1355,22 +1356,22 @@ class Deva {
     - st: The state flag to set for the Deva that matches to this._states
   describe
   ***************/
-  action(action, data=false) {
+  action(action) {
     try {
       if (!this._actions[action]) return;
       this._action = action;
       const text = this._messages.actions[action];
       const _data = {
-        id: this.uid(),
+        id: this.uid(true),
         key: 'action',
         value: action,
-        agent: this._agent,
+        agent: this.agent(),
+        client: this.client(),
         text,
-        data,
         created: Date.now(),
       };
       _data.hash = this.hash(JSON.stringify(_data));
-      this.talk('action', _data);
+      this.talk('devacore:action', this.copy(_data));
     } catch (e) {
       return this.error(e)
     }
@@ -1388,7 +1389,7 @@ class Deva {
       this._feature = feature;
       const text = this._messages.features[feature] ;
       const _data = {
-        id: this.uid(),
+        id: this.uid(true),
         key: 'feature',
         value: feature,
         agent: this._agent,
@@ -1417,7 +1418,10 @@ class Deva {
   client() {
     this.state('client_data');                                // set the client state
     if (!this._active) return this._messages.states.offline;    // check the active status
-    return this._client;                                 // return the client feature
+    const client_copy = this.copy(this._client);
+    // delete client_copy.parse;
+    // delete client_copy.translate;
+    return client_copy;                                 // return the client feature
   }
 
   /**************
@@ -1431,7 +1435,10 @@ class Deva {
   agent() {
     this.state('agent_data');
     if (!this._active) return this._messages.states.offline;
-    return this._agent;
+    const agent_copy = this.copy(this._agent);
+    delete agent_copy.parse;
+    delete agent_copy.translate;
+    return agent_copy;
   }
 
   // FEATURE FUNCTIONS
@@ -1638,7 +1645,7 @@ class Deva {
       try {
         this.state('uload');
         delete this.devas[key];
-        this.talk(`deva:unload`, {
+        this.talk(`unload`, {
           key,
           created: Date.now(),
         });
@@ -1735,14 +1742,7 @@ class Deva {
     const decipher = createDecipheriv( algorithm, key_in_bytes, iv);
     const decrypted = decipher.update(encrypted);
     const final = Buffer.concat([decrypted, decipher.final()]);
-    this.state('decipher', {
-      id: this.uid(true),
-      iv: opt.iv,
-      key: opt.key,
-      agent_id: this._agent.id,
-      client_id: this._client.id,
-      created: Date.now()
-    });
+    this.state('decipher');
     return final.toString();
   }
 
@@ -1778,13 +1778,15 @@ class Deva {
   usage: this.prompt('text')
   ***************/
   prompt(text) {
-    // console.log('PROMPT', text);
     // Talk a global prompt event for the client
-    return this.talk('prompt', {
+    return this.talk('devacore:prompt', {
       id: this.uid(),
+      key: 'return',
+      value: 'prompt',
+      agent: this.agent(),
+      client: this.client(),
       text,
-      agent:this._agent,
-      created: Date.Now(),
+      created: Date.now(),
     });
   }
 
@@ -1802,12 +1804,31 @@ class Deva {
     let v, key;
     const output = Array.isArray(obj) ? [] : {};
     for (key in obj) {
-        v = obj[key];
-        output[key] = (typeof v === "object") ? this.copy(v) : v;
+      v = obj[key];
+      output[key] = (typeof v === "object") ? this.copy(v) : v;
     }
     return output;
   }
 
+  /**************
+  func: getToday
+  params:
+    - d: The date string to get the day of..
+  describe:
+    a date can be passed in or generated to produce a date string for the day
+    where time is 0. This feature is useful for logging for getting a date
+    with no time value for the current day.
+  ***************/
+  getToday(d) {
+    d = d ? d : Date.now();
+    const today = new Date(d);
+    today.setHours(0);
+    today.setMinutes(0);
+    today.setSeconds(0);
+    today.setMilliseconds(0);
+    return today.getTime();
+  }
+
   /**************
   func: formatDate
   params:
@@ -1877,5 +1898,46 @@ class Deva {
     return parseFloat(n).toFixed(dec) + '%';
   }
 
+  /**************
+  func: error
+  params:
+    - err: The error to process
+    - data: Any additional data associated with the error
+    - reject: An associated promise reject if the caller requires.
+  describe:
+    The erro function rpovides the consistent error manage of the system.
+  usage: this.error(err, data, reject);
+  ***************/
+  error(err,data=false,reject=false) {
+    this.state('error');
+    // check fo rthe custom onError function in the agent.
+    console.log('\n::BEGIN:ERROR\n');
+    console.log(err);
+    console.log('\n::END:ERROR\n');
+    if (data) {
+      console.log('::::::');
+      console.log('\n::BEGIN:DATA\n');
+      console.log(JSON.stringify(data, null, 2));
+      console.log('\n::END:DATA\n');
+    }
+
+    this.talk('devacore:error', {
+      id: this.uid(true),
+      key: 'return',
+      value: 'error',
+      agent: this.agent(),
+      client: this.client(),
+      text: err.toString(),
+      data,
+      created: Date.now(),
+    });
+
+    const hasOnError = this.onError && typeof this.onError === 'function' ? true : false;
+    if (hasOnError) return this.onError(err, data, reject);
+    else {
+      return reject ? reject(err) : err;
+    }
+  }
+
 }
 module.exports = Deva;