Added agent and memory commands

Author: zabirauf

app/commands/agents.ts

@@ -0,0 +1,81 @@
+import { LLMMessage, LLMModel, callLLMChatCompletion } from "~/utils/llmUtils";
+import { Config } from "~/utils/config";
+
+export interface Agent {
+  name: string;
+  task: string;
+  messages: LLMMessage[];
+  model: LLMModel;
+}
+
+let nextkey = 0;
+const agents: {[key: string]: Agent} = {};
+
+export async function startAgent(
+  name: string,
+  task: string,
+  prompt: string,
+  model: LLMModel = Config.fast_llm_model
+) {
+    const firstMessage = `You are ${name}. Respond with: "Acknowledged".`;
+    const { key, agentReply } = await createAgent(name, task, firstMessage, model);
+
+    const agentResponse = await messageAgent(key, prompt);
+
+    return `Agent ${name} created with key ${key}. First response: ${agentResponse}`;
+}
+
+export async function createAgent(
+  name: string,
+  task: string,
+  prompt: string,
+  model: LLMModel
+): Promise<{ key: string; agentReply: string }> {
+  const messages: LLMMessage[] = [{ role: "user", content: prompt }];
+
+  const agentReply = await callLLMChatCompletion(messages, model);
+
+  messages.push({ role: "assistant", content: agentReply });
+
+  const agent: Agent = {
+    name,
+    task,
+    messages,
+    model,
+  };
+  const key = `${nextkey}`;
+  nextkey = nextkey + 1;
+
+  agents[key] = agent;
+
+  return { key, agentReply };
+}
+
+export async function messageAgent(
+  key: string,
+  message: string
+): Promise<string> {
+  if (!agents[key]) {
+    return "Invalid key, agent doesn't exist";
+  }
+  const { messages, model } = agents[key];
+  messages.push({ role: "user", content: message });
+
+  const agentReply = await callLLMChatCompletion(messages, model);
+
+  messages.push({ role: "assistant", content: agentReply });
+  return agentReply;
+}
+
+export function listAgents(): [string, string][] {
+  return Object.keys(agents).map((key: string) => [key, agents[key].task]);
+}
+
+export function deleteAgent(key: string): boolean {
+  if (agents[key]) {
+    delete agents[key];
+    return true;
+  }
+
+  return false;
+}

app/commands/index.ts

@@ -0,0 +1,36 @@
+import { startAgent, deleteAgent, messageAgent, listAgents } from "./agents";
+import {
+  overwriteMemory,
+  deleteMemory,
+  commitMemory,
+} from "./memory";
+import { Config } from "~/utils/config";
+
+export async function executeCommand(
+  command: string,
+  args: { [key: string]: string }
+): Promise<string> {
+  try {
+    if (command === "memory_add") {
+      return commitMemory(args["string"]);
+    } else if (command === "memory_del") {
+      return deleteMemory(parseInt(args["key"]));
+    } else if (command === "memory_ovr") {
+      return overwriteMemory(parseInt(args["key"]), args["string"]);
+    } else if (command === "start_agent") {
+      return await startAgent(args["name"], args["task"], args["prompt"]);
+    } else if (command === "message_agent") {
+      return await messageAgent(args["key"], args["message"]);
+    } else if (command === "list_agents") {
+      return JSON.stringify(listAgents());
+    } else if (command === "delete_agent") {
+      return deleteAgent(args["key"])
+        ? `Agent ${args["key"]} deleted.`
+        : `Agent ${args["key"]} does not exist.`;
+    } else {
+        return `Unknown command ${command}`;
+    }
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}

app/commands/memory.ts

@@ -0,0 +1,31 @@
+const permanentMemory: string[] = [];
+
+export function commitMemory(val: string) {
+    permanentMemory.push(val);
+
+    return `Committing memory with string "${val}"`;
+}
+export function getMemory(index: number) {
+    if (index >= permanentMemory.length) {
+        return 'Invalid key, cannot retrieve memory.';
+    }
+    return permanentMemory[index];
+}
+
+export function deleteMemory(index: number) {
+    if (index >= permanentMemory.length) {
+        return 'Invalid key, cannot delete memory.';
+    }
+ 
+    permanentMemory.splice(index, 1);
+    return `Deleting memory with key ${index}.`;
+}
+
+export function overwriteMemory(index: number, val: string) {
+    if (index >= permanentMemory.length) {
+        return 'Invalid key, cannote overwrite memory.'
+    }
+
+    permanentMemory[index] = val;
+    return `Overwriting memory with key ${index} and string "${val}".`;
+}

app/utils/apiKey.ts

@@ -0,0 +1,9 @@
+let OPENAI_API_KEY: string | null = null;
+
+export function getAPIKey() {
+    return OPENAI_API_KEY;
+}
+
+export function setAPIKey(apiKey: string) {
+    OPENAI_API_KEY = apiKey;
+}

app/utils/config.ts

@@ -0,0 +1,3 @@
+export const Config = {
+    fast_llm_model: 'gpt-3.5-turbo' as const
+}

app/utils/llmUtils.ts

@@ -0,0 +1,46 @@
+import { getAPIKey } from "./apiKey";
+
+export type LLMMessage =
+  | { role: "system"; content: string; }
+  | { role: "assistant"; content: string; }
+  | { role: "user"; content: string; };
+
+export type LLMModel =
+  | "gpt-3.5-turbo"
+  | "gpt-3.5-turbo-0301"
+  | "gpt-4"
+  | "gpt-4-0314";
+
+export async function callLLMChatCompletion(
+  messages: LLMMessage[],
+  model: LLMModel,
+  temperature?: number,
+  maxTokens?: number
+) {
+  const reqBody = {
+    model,
+    messages,
+    temperature,
+    max_tokens: maxTokens,
+  };
+
+  const apiKey = getAPIKey();
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${apiKey}`);
+
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers,
+    body: JSON.stringify(reqBody),
+  });
+
+  if (response.status !== 200) {
+    const errorText = await response.text();
+    console.error("Error calling OpenAI service", response.status, errorText);
+    return `Error calling API with status code ${response.status} and message "${errorText}"`;
+  }
+
+  const resBody = await response.json();
+
+  return resBody.data.choices[0].message as string;
+}