Socket message structure

README.md

@@ -1,3 +1,17 @@
+### Agent state
+
+Each agent stores its state under the `.store` directory. Agent 1, for example has
+
+```
+.store/1/memory
+.store/1/goals
+.store/1/notes
+```
+
+You can simply delete any of these things, or the whole agent folder (or the whole `.store`) to selectively wipe whatever state you want between runs. Otherwise agents will pick up where you left off on restart.
+
+A nice aspect of this is that when you want to debug a problem you ran into with a particular agent, you can delete the events in their memory subsequent to the point where the problem occurred, make changes to the code, and restart them to effectively replay that moment until you've fixed the bug. You can also ask an agent to implement a feature, and once they've done so you can restart, tell them that you've loaded the feature and ask them to try it out.
+
 # AI Legion: an LLM-powered autonomous agent platform
 
 A framework for autonomous agents who can work together to accomplish tasks.
@@ -29,7 +43,8 @@ You'll also need to enable the Google Custom Search API for your Google Cloud ac
 Start the program:
 
 ```
-npm run start [# of agents] [gpt-3.5-turbo|gpt-4]
+npm run start agents=[# of agents] model=[gpt-3.5-turbo|gpt-4]
+
 ```
 
 Interact with the agents through the console. Anything you type will be sent as a message to all agents currently.

package.json

@@ -31,6 +31,7 @@
     "@types/lodash": "^4.14.191",
     "@types/node": "^18.15.3",
     "@types/turndown": "^5.0.1",
+    "chalk": "^5.2.0",
     "dotenv": "^16.0.3",
     "googleapis": "^114.0.0",
     "gpt-3-encoder": "^1.1.4",
@@ -40,6 +41,7 @@
     "prettier": "^2.8.7",
     "puppeteer": "^19.8.5",
     "redis": "^4.6.5",
+    "socket.io": "^4.6.1",
     "ts-jest": "^29.0.5",
     "turndown": "^7.1.2",
     "ws": "^8.13.0"

src/agent.ts

@@ -9,6 +9,7 @@ import parseAction from "./parse-action";
 import TaskQueue from "./task-queue";
 import { agentName, sleep } from "./util";
 
+const AGENT_ID = "0";
 const actionInterval = 1000;
 // const heartbeatInterval = 60 * 1000;
 
@@ -57,15 +58,35 @@ export class Agent {
       // Do not act again if the last event was a decision
       if (last(events)?.type === "decision") return;
 
+      const t0 = Date.now();
+      this.messageBus.send(
+        messageBuilder.agentToAgent(
+          this.id,
+          [AGENT_ID],
+          `Reflecting on ${events.length} events...`
+        )
+      );
+
       const actionText = await makeDecision(events);
 
+      this.messageBus.send(
+        messageBuilder.agentToAgent(
+          this.id,
+          [AGENT_ID],
+          `Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(
+            1
+          )}s  \n\n ${actionText}`
+        )
+      );
+
       // Reassign events in case summarization occurred
       events = await this.memory.append({
         type: "decision",
         actionText,
       });
 
       const result = parseAction(this.moduleManager.actions, actionText);
+
       if (result.type === "error") {
         this.messageBus.send(messageBuilder.error(this.id, result.message));
       } else {

src/in-memory-message-bus.ts

@@ -18,6 +18,7 @@ export class InMemoryMessageBus implements MessageBus {
   }
 
   send(message: Message): void {
+    console.log("message bus console ===>", message);
     this.emitter.emit("message", message);
   }
 }

src/main.ts

@@ -13,10 +13,12 @@ import notes from "./module/definitions/notes";
 import web from "./module/definitions/web";
 import { ModuleManager } from "./module/module-manager";
 import { contextWindowSize } from "./openai";
-import { model, numberOfAgents } from "./parameters";
+
+import { model, numberOfAgents, test } from "./parameters";
+
 import FileStore from "./store/file-store";
 import JsonStore from "./store/json-store";
-import { webSocketServer } from "./web-socket-server";
+import webSocketServer from "./socket-server/socket-server";
 
 dotenv.config();
 
@@ -29,34 +31,42 @@ main();
 async function main() {
   startConsole(agentIds, messageBus);
 
-  webSocketServer(messageBus, 8080);
-
-  for (const id of agentIds.slice(1)) {
-    const moduleManager = new ModuleManager(id, agentIds, [
-      core,
-      goals,
-      notes,
-      messaging,
-      filesystem,
-      web,
-    ]);
-    const actionHandler = new ActionHandler(
-      agentIds,
-      messageBus,
-      moduleManager
-    );
-
-    const store = new JsonStore<Event[]>(new FileStore([id]));
-    // We have to leave room for the agent's next action, which is of unknown size
-    const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);
-    const memory = new Memory(id, moduleManager, store, compressionThreshold);
-    const agent = new Agent(
-      id,
-      memory,
-      messageBus,
-      moduleManager,
-      actionHandler
-    );
-    await agent.start();
+  webSocketServer(messageBus, 4331, agentIds);
+
+  if (!test) {
+    for (const id of agentIds.slice(1)) {
+      const moduleManager = new ModuleManager(id, agentIds, [
+        core,
+        goals,
+        notes,
+        messaging,
+        filesystem,
+        web,
+      ]);
+      const actionHandler = new ActionHandler(
+        agentIds,
+        messageBus,
+        moduleManager
+      );
+
+      const store = new JsonStore<Event[]>(new FileStore([id]));
+      // We have to leave room for the agent's next action, which is of unknown size
+      const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);
+      const memory = new Memory(
+        id,
+        moduleManager,
+        store,
+        compressionThreshold,
+        messageBus
+      );
+      const agent = new Agent(
+        id,
+        memory,
+        messageBus,
+        moduleManager,
+        actionHandler
+      );
+      await agent.start();
+    }
   }
 }

src/make-decision.ts

@@ -12,7 +12,6 @@ const taskQueue = new TaskQueue();
 export default function makeDecision(events: Event[]): Promise<string> {
   const decisionPromise = taskQueue.run(async (): Promise<string> => {
     console.log(`Reflecting on ${events.length} events...`);
-    const t0 = Date.now();
 
     const messages = events.map(toOpenAiMessage);
 
@@ -25,10 +24,6 @@ export default function makeDecision(events: Event[]): Promise<string> {
       temperature,
     });
 
-    console.log(
-      `Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
-    );
-
     return responseContent;
   });
 

src/memory/memory.ts

@@ -1,6 +1,7 @@
 import { Event } from ".";
 import makeDecision, { toOpenAiMessage } from "../make-decision";
 import { messageBuilder } from "../message";
+import { MessageBus } from "../message-bus";
 import { ModuleManager } from "../module/module-manager";
 import { Store } from "../store";
 import {
@@ -17,7 +18,8 @@ export class Memory {
     private agentId: string,
     private moduleManager: ModuleManager,
     private store: Store<Event[]>,
-    private compressionThreshold: number
+    private compressionThreshold: number,
+    private messageBus: MessageBus
   ) {}
 
   async append(event: Event): Promise<Event[]> {

src/message.ts

@@ -3,6 +3,7 @@ export interface Message {
   source: MessageSource;
   targetAgentIds: string[];
   content: string;
+  activeAgents?: string[];
 }
 
 type TypelessMessage = Omit<Message, "type">;

src/parameters.ts

@@ -1,18 +1,66 @@
-import { GPT_3_5_TURBO, GPT_4, Model } from "./openai";
-
-const args = process.argv.slice(2); // Remove the first two elements (Node.js executable and script path)
-
-export const numberOfAgents = args.length > 0 ? parseInt(args[0]) : 1;
-console.log(`Number of agents: ${numberOfAgents}`);
-
-const modelText = args.length > 1 ? args[1] : "gpt-3.5-turbo";
-export let model: Model;
-switch (modelText) {
-  case GPT_3_5_TURBO:
-  case GPT_4:
-    model = modelText;
-    break;
-  default:
-    throw Error(`Unrecognized OpenAI model: '${modelText}'`);
+import { Model } from "./openai";
+
+interface CommandLineFlags {
+  numberOfAgents: number;
+  model: Model;
+  test: boolean;
+}
+
+function processFlags(args: string[]): CommandLineFlags {
+  const flags: CommandLineFlags = {
+    numberOfAgents: 1,
+    model: "gpt-3.5-turbo",
+    test: false,
+  };
+
+  for (const arg of args) {
+    const [flag, value] = arg.split("=");
+
+    switch (flag) {
+      case "agents":
+        if (isNaN(parseInt(value))) {
+          throw new Error("Error: --agents flag value must be a number");
+        }
+        flags.numberOfAgents = parseInt(value);
+        break;
+
+      case "model":
+        if (value !== "String") {
+          throw new Error('Error: --model flag value must be "String"');
+        }
+        flags.model = value as Model;
+        break;
+
+      case "test":
+        if (
+          !value ||
+          (value.toLowerCase() !== "true" && value.toLowerCase() !== "false")
+        ) {
+          throw new Error('Error: --test flag value must be "true" or "false"');
+        }
+        flags.test = value.toLowerCase() === "true";
+        break;
+
+      case "help":
+        console.log(` Options:          
+
+        agents=X                       Set the value of numberOfAgents to X, where X is a number between 1-12
+        model=gpt-3.5-turbo | gpt-4    Set the value of the model to "String", which should match the Message interface
+        test=true|false                Set the test value as a boolean (either "true" or "false")
+        help                           Display this help message and exit
+    `);
+
+        process.exit();
+        break;
+      default:
+        break;
+    }
+  }
+
+  return flags;
 }
-console.log(`Model: ${model}`);
+
+const commandLineArgs = process.argv.slice(2);
+const { model, numberOfAgents, test } = processFlags(commandLineArgs);
+
+export { model, numberOfAgents, test };

src/socket-server/command-actions.ts

@@ -0,0 +1,37 @@
+export const CommandActions = () => {
+  return {
+    startSystem: () => {
+      console.log("startSystem..........");
+      // Implement start system logic
+    },
+
+    stopSystem: () => {
+      console.log("stopSystem..........");
+      // Implement stop system logic
+    },
+
+    addAgent: (content: { id: string; name?: string; type?: string }) => {
+      // Implement add agent logic
+    },
+
+    removeAgent: (content: { id: string }) => {
+      // Implement remove agent logic
+    },
+
+    stopAgent: (content: { id: string }) => {
+      // Implement stop agent logic
+    },
+
+    startAgent: (content: { id: string }) => {
+      // Implement start agent logic
+    },
+
+    changeAgentType: (content: { id: string; type: string }) => {
+      // Implement change agent type logic
+    },
+
+    changeAgentName: (content: { id: string; name: string }) => {
+      // Implement change agent name logic
+    },
+  };
+};

src/socket-server/command-reducer.ts

@@ -0,0 +1,47 @@
+import {
+  CommandActionsEnum,
+  CommandActionsType,
+  CommandActionToMessage,
+} from "./command-types";
+
+export type CommandMessage =
+  CommandActionToMessage[keyof CommandActionToMessage];
+
+type ProcessMessageFunction = (
+  message: CommandMessage,
+  actions: CommandActionsType
+) => void;
+
+export const commandMessageReducer: ProcessMessageFunction = (
+  message,
+  actions
+) => {
+  switch (message.action) {
+    case CommandActionsEnum.Start:
+      actions.startSystem();
+      break;
+    case CommandActionsEnum.Stop:
+      actions.stopSystem();
+      break;
+    case CommandActionsEnum.AddAgent:
+      actions.addAgent(message.content);
+      break;
+    case CommandActionsEnum.RemoveAgent:
+      actions.removeAgent(message.content);
+      break;
+    case CommandActionsEnum.StopAgent:
+      actions.stopAgent(message.content);
+      break;
+    case CommandActionsEnum.StartAgent:
+      actions.startAgent(message.content);
+      break;
+    case CommandActionsEnum.ChangeAgentType:
+      actions.changeAgentType(message.content);
+      break;
+    case CommandActionsEnum.ChangeAgentName:
+      actions.changeAgentName(message.content);
+      break;
+    default:
+      console.error("Invalid action:");
+  }
+};