@indra.ai/deva 1.0.31 → 1.0.34

package/README.md

@@ -1,15 +1,77 @@
 # deva
 
-Deva is a class object that provides events and object management with inherited properties.
+## Summary
+Deva is a Node.js module designed to simplify the development of multi-agent systems by providing a consistent foundation for agent interactions. With Deva, developers can quickly create and manage a network of agents that can communicate and collaborate seamlessly. Deva offers features such as private and public socket communication, secure encryption, and consistent message passing. It also provides built-in support for interacting with various APIs, including YouTube, Twitter, Discord, IBM Watson, and ChatGPT. By using Deva, developers can save time and resources in building and integrating basic agent functionalities, and focus on developing more advanced features.
 
-[Back to indra.ai](https://indra.ai)
+## Description
 
-## Install
+The Deva module is a JavaScript library for building multi-agent systems that can communicate with each other and with external services. It provides a unified API for creating agents and defining their behaviors, and includes tools for handling communication between agents and for integrating with third-party APIs. The Deva module is designed to be flexible and customizable, allowing developers to easily create complex systems that can perform a wide range of tasks, from data collection and analysis to chatbot interactions and image generation. The module is written in JavaScript and can be used with Node.js, making it easy to integrate with other JavaScript libraries and tools.
+
+## functions
+
+- Dynamic Agent Loading - The Deva module allows for dynamic agent loading, which means that agents can be loaded and unloaded on the fly as needed. This provides scalability for the multi-agent system, as agents can be added or removed as demand changes.
+
+- Talk/Listen events - The module uses talk/listen events for agent broadcasting. This means that agents can communicate with each other by sending messages through the event pipeline. This allows for real-time communication and coordination between agents.
+
+- Question, Answer - The main function of the Deva module is to handle questions and answers between agents. When an agent has a question, it can send it to another agent using the "question" function. The receiving agent can then process the question and send an answer back using the "answer" function.
+
+- Ask feature - The Deva module includes an "ask" feature that allows one agent to ask another agent a question directly. This is useful for agents that need to communicate with each other in a targeted way.
+
+- State Management - The module includes state management to initiate and track agent processes at different load, process, and exist states. This allows for better tracking and management of agent processes, and helps ensure that the system is running smoothly.
+
+- Error Management - The Deva module includes robust error management to handle unexpected errors or exceptions that may occur during the execution of agent processes. This helps ensure that the system is reliable and stable.
+
+- Unifies data-packets - The Deva module unifies data-packets across the architecture, allowing for consistent data exchange between agents regardless of the platform or service they are using. This helps ensure that data is consistent and accurate throughout the system.
+
+
+## Uses
+
+### Corporate
+
+A corporation might use the Deva module to create an intelligent assistant to handle customer inquiries and support requests. By leveraging the Deva module's dynamic agent loading, state management, and unified data-packets features, the corporation can easily scale the intelligent assistant to handle a large volume of customer interactions across various channels, such as social media, email, and chat platforms.
+
+The intelligent assistant can be trained using machine learning algorithms and natural language processing to understand customer inquiries and provide relevant responses or escalate to a human agent if necessary. The Deva module's error management feature ensures that any errors or issues are handled smoothly and efficiently, without interrupting the customer's experience.
+
+Additionally, the Deva module can be used by a corporation to automate various internal processes and workflows, such as data processing, task management, and communication between teams. By leveraging the Deva module's question-answer functionality and dynamic agent loading, corporations can easily create custom workflows and automate tedious tasks, increasing productivity and efficiency.
+
+### Science
+
+A scientist could use the Deva module in a number of ways. For example, they could create agents to help with data analysis or modeling, or to interact with other software tools in the research process. The Deva module's ability to dynamically load agents and unify data across different platforms could also be useful in streamlining scientific workflows and collaborations between research groups. Additionally, the natural language processing capabilities of the ChatGPT agent could be utilized to help with tasks such as literature reviews or generating hypotheses. Overall, the Deva module could be a valuable tool for scientists looking to enhance their research process with the help of intelligent agents.
+
+
+#Scalability
+
+The Deva module has a high potential for scalability because of its dynamic agent loading feature. This means that new agents can be added to the system at runtime without the need for a system restart or manual intervention. The module is also designed to work with state management to track agent processes at different load, process, and exit states. This makes it possible to scale the system horizontally by adding more computing resources to handle increased load, or vertically by adding more powerful hardware to each node in the system. Overall, the Deva module is well suited for building large-scale, distributed agent-based systems that can handle complex and diverse workloads.
+
+## ChatGPT Quote
+
+Here is what ChatPGT has to say about the Deva module:
+
+Based on my analysis of the Deva Module, I believe it is a powerful tool for developing multi-agent systems. Its dynamic agent loading and scalability potential make it a great choice for large-scale projects. The talk/listen events, question/answer functions, and ask feature allow for easy communication between agents. Additionally, its state management and error handling capabilities help to ensure the reliability and stability of the system. Finally, its unification of data-packets across the architecture makes it easy to integrate with a variety of services and platforms.
+
+Overall, I believe the Deva Module is a well-designed and flexible tool that can be used in a variety of applications, from corporate to scientific. Its potential for scalability and security make it a great choice for large-scale projects, while its ease of use and integration make it accessible to developers of all levels.
+
+
+## contents
+- [install](#install) - How to install the deva core.
+- [structure](#structure) - Basic structure of `deva`.
+- [agent](#agent) - The `agent` object stores the Agent Profile.
+- [vars](#vars) - Variables are stored in the `this.vars` object.
+- [listeners](#listeners) - Listeners are setup to allow a deva trigger events.
+- [devas](#listeners) - This is where sub-devas are loaded into the current deva.
+- [modules](#modules) - A `deva` can add modules to add to their functionality.
+- [func](#func) - A `deva` the internal functionality is written here.
+- [methods](#methods) - Methods expose the `deva` abilities to external commands/calls.
+- [states](#states) - There are various states that triger when a `deva` is doing things.
+- [utility](#utility) - Interal to a `deva` there are utility functions available to make actions easier like getting a unique id or status.
+
+
+## install
 ```bash
-$ npm i @indra.ai/deva --save-dev
+$ npm i @indra.ai/deva --save
 ```
 
-## Basic Structure
+## structure
 ```javascript
 // include the main Deva class
 const Deva = require('feecting/deva');
@@ -63,13 +125,14 @@ deva.init();
 
 ```
 
-## Breakdown
-### Agent
+## agent
+
 ```javascript
 this.agent
 ```
 The "me" object contains the profile information for the DEVA.
-##### Data Attributes
+
+### Data Attributes
 - **uid:** The unique id for the Deva.
 - **key:** The unique key for the Deva.
 - **name:** The name of the Deva.
@@ -88,17 +151,18 @@ The "me" object contains the profile information for the DEVA.
   - **gender:** The gender of the Deva
   - **describe:** A short description of the deva 100 characters or less.
 
-### Vars
+## vars
+
 ```javascript
 this.vars
 ```
+
 The vars can be use to set local variables for the deva that need to be used in your program.
 
 There are no default variables, so the scope is for you and your imagination to figure out.
 
-##### Example
+### example
 ```javascript
-...
   vars: {
     foo: 'bar',
     steps: 10,
@@ -112,64 +176,57 @@ There are no default variables, so the scope is for you and your imagination to
       'value 2',
     ]
   }
-...
-
 ```
-### Listeners
+
+## listeners
 Listeners are what you setup that allow your Deva to communicate with other Deva or parts of your application/system.
 
 ```javascript
 this.listeners
 ```
 
-#### Default Listeners
+### default
 
 Each Deva comes with a set of default listeners to provide basic functionality.
 
-##### Question
-The question event is the functionality that exposes the methods to the outside world. When a deva asks a question the string is parsed into a question format so that commands to access various methods can be exposed.
-
-```javascript
-const question = await this.question(`#*agent_key* *method*:*params* *question string*`);
-```
-
-##### Start
+### start
 This will trigger an event to start the Deva.
 
 ```javascript
 this.talk(`*agent_key*:start`);
 ```
 
-##### Stop
+### stop
 This will trigger an event to stop the Deva.
 
 ```javascript
 this.talk(`*agent_key*:stop`);
 ```
 
-##### Status
+### status
 This will trigger an event to broadcast the Deva status.
 
 ```javascript
 this.talk(`*agent_key*:status`);
 ```
 
-### Deva
+## devas
+
 ```javascript
-this.deva
+this.devas
 ```
 
 The main object for Deva that are bwlow this Deva.
 
-### Modules
+## modules
+
 The external modules that your Deva might require to function.
 
 ```javascript
 this.modules
 ```
 
-
-### Func
+## func
 The functions that your deva uses to operate. Functions are not exposed through
 the api to public access.
 
@@ -177,17 +234,18 @@ the api to public access.
 this.func
 ```
 
-### Methods
+### methods
 ```javascript
 this.methods
 ```
+
 The methods are exposed publicly through the question event that parses a string
 and sends a request to the question method that then interacts with functions, modules, and variables.
 
-### State Functions
+## states
 Provided are a set of state functions that trigger when a Deva is at various states of starting/stopping.
 
-#### onStart()
+### onStart()
 
 The `onStart()` function runs after the `start` function has completed.
 
@@ -197,7 +255,7 @@ this.onStart() {
 }
 ```
 
-#### onStop()
+### onStop()
 
 The `onStop()` function runs after the `stop` function has completed.
 
@@ -207,8 +265,7 @@ this.onStop() {
 }
 ```
 
-
-#### onEnter()
+### onEnter()
 
 The `onEnter()` function runs after the `enter` event has fired.
 
@@ -218,8 +275,7 @@ this.onEnter() {
 }
 ```
 
-
-#### onExit()
+### onExit()
 
 The `onExit()`function runs after the `exit` event has fired.
 
@@ -229,7 +285,7 @@ this.onExit() {
 }
 ```
 
-#### onDone()
+### onDone()
 
 The `onDone()`function runs after the `done` event has fired.
 
@@ -239,8 +295,7 @@ this.onDone() {
 }
 ```
 
-
-#### onInit()
+### onInit()
 
 The `onInit()` function runs after the `init()` function has completed.
 
@@ -250,14 +305,36 @@ this.onInit() {
 }
 ```
 
-## Utility Functions
+## utility
+
+### question
+
+The question event is the functionality that exposes the methods to the outside world. When a deva asks a question the string is parsed into a question format so that commands to access various methods can be exposed.
+
+The `question(packet)` function is a default function that allows the system to ask questions of itself or other Deva.
+
+The function checks the beginning of a string for a `#` to determine wether to issue a command to run a specific method.
+
+See [Question Listener](#question) for usage.
+
+
+```javascript
+// async await
+const question = await this.question('#*agent_key* *method*:*params* *question string*');
+
+// promises
+this.question('#*agent_key* *method*:*params* *question string*').then(response => {
+  ...
+}).catch(err => {
+  ...
+})
+```
 
 ### uid()
 Generates a unique ID that is used in packet transfer and other various ways.
 
 ```javascript
 this.uid() // inside the object
-deva.uid() // outside the object
 
 // example
 this.vars.id = this.uid()
@@ -334,13 +411,13 @@ this.func.listener = packet => {
 ```
 
 
-### Load(agent, opts)
+### load(agent, opts)
 
 To add a Deva dynamically use the `load()` function. This can be utilized to add Deva to an existing Deva after the object has already been created.
 
 ```javascript
 const opts = {
-  me: {...},
+  agent: {...},
   vars: {...},
   listeners: {...},
   deva: {...},
@@ -362,18 +439,6 @@ this.unload('deva-key');
 
 ```
 
-### question(packet)
-The `question(packet)` function is a default function that allows the system to ask questions of itself or other Deva.
-
-The function checks the beginning of a string for a `#` to determine wether to issue a command to run a specific method.
-
-See [Question Listener](#question) for usage.
-
-```bash
-#deva method:params message
-```
-
-
 ### status()
 The `status()` function will return the running status of the current Deva.
 
@@ -389,6 +454,8 @@ The `init()` function will initialize the Deva and run the `onInit()` state func
 ### initDeva()
 The `initDeva()` function will initialize the Deva located under the current Deva set. To be used in instances of a main Deva parent situation.
 
--
+---
+
+[Github Repo](https://github.com/indraai/deva)  
 [Back to indra.ai](https://indra.ai)  
 ©2021 Quinn Michaels; All Rights Reserved.

package/_config.yml

@@ -0,0 +1,7 @@
+# Copyright 2022 Quinn Michaels.
+
+author:
+  name: Quinn Michaels
+  email: "qce@indra.ai"
+
+google_analytics: UA-126646842-1

package/index.js

@@ -472,12 +472,12 @@ class Deva {
     return Promise.resolve({text});
   }
 
-  // universal prompt emitter
+  // prompt emitter
   prompt(text) {
-    this.talk('prompt', {text, prompt:this.agent.prompt});
+    this.talk('prompt', {text, agent:this.agent});
   }
 
-  // universal hash builder
+  // hash builder
   hash(packet) {
     if (!this.vars.hash) this.vars.hash = '0x';
     // setup basic hashing
@@ -500,9 +500,9 @@ class Deva {
       });
     });
   }
-  // initDeva interface is to initialize devas that this deva is a parent of.
+  // startDevas interface is to initialize devas that this deva is a parent of.
   // This feature allows a Deva to be a parent of a parent of a parent etc....
-  initDevas() {
+  startDevas() {
     return new Promise((resolve, reject) => {
       const devas = [];
       for (let x in this.devas) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indra.ai/deva",
-  "version": "1.0.31",
+  "version": "1.0.34",
   "description": "The Deva Core",
   "main": "index.js",
   "scripts": {