symposium 0.1.0

package/Agent.js

@@ -0,0 +1,371 @@
+import OpenAI from "openai";
+import {Conversation} from "./Conversation.js";
+
+class Agent {
+	name = 'Agent';
+	descriptionForFront = '';
+	options = {};
+	openai;
+	conversations;
+	functions = null;
+	middlewares = new Map();
+	tools = new Map();
+	commands;
+
+	constructor(options) {
+		this.options = {
+			memory_handler: null,
+			...options,
+		};
+
+		if (this.options.memory_handler)
+			this.options.memory_handler.setAgent(this);
+
+		this.models = [
+			{
+				label: 'gpt-3.5',
+				name: 'gpt-3.5-turbo-16k',
+				tokens: 16384,
+			},
+			{
+				label: 'gpt-4',
+				name: 'gpt-4',
+				tokens: 8192
+			}
+		];
+
+		this.commands = new Map();
+
+		this.commands.set('start', {
+			description: '',
+			show_in_help: false,
+			exec: async conversation => {
+				await conversation.reply('Benvenuto! Digita /help per un aiuto sui comandi, oppure procedi pure se già sai come usare.');
+			}
+		});
+
+		this.commands.set('model', {
+			description: 'Per impostare l\'utilizzo di GPT 3 o 4 (o vedere il modello che si sta usando)',
+			show_in_help: true,
+			exec: async (conversation, args) => {
+				if (args) {
+					const model_to_switch = this.getModelFromLabel(args);
+					if (model_to_switch) {
+						await conversation.setState({model: model_to_switch.name});
+						await conversation.reply('# Da ora in poi uso ' + model_to_switch.label + '!');
+					} else {
+						await conversation.reply("# Versione modello non riconosciuta!\nModelli disponibili:\n" + this.models.map(m => m.label).join("\n"));
+					}
+				} else {
+					const currentModel = this.getModelFromName(conversation.state.model);
+					await conversation.reply('# Il modello attualmente in uso è ' + currentModel.label);
+				}
+			},
+		});
+
+		this.commands.set('reset', {
+			description: 'Reimposta la conversazione, facendo dimenticare al bot tutto ciò che viene prima',
+			show_in_help: true,
+			exec: async conversation => {
+				await this.reset(conversation);
+				await conversation.reply('# Conversazione resettata');
+			}
+		});
+
+		this.commands.set('logout', {
+			description: 'Reimposta i token di autenticazione',
+			show_in_help: true,
+			exec: async conversation => {
+				await this.logout(conversation);
+				await conversation.reply('# Logout effettuato');
+			}
+		});
+
+		this.commands.set('help', {
+			description: 'Aiuto sui comandi',
+			show_in_help: true,
+			exec: async conversation => {
+				let help = "Comandi disponibili:\n";
+				for (let command of this.commands.entries()) {
+					if (!command[1].show_in_help)
+						continue;
+					help += '/' + command[0];
+					if (command[1].description)
+						help += ' -> ' + command[1].description;
+					help += "\n";
+				}
+
+				await conversation.reply(help);
+			}
+		});
+
+		this.openai = new OpenAI({
+			apiKey: process.env.OPENAI_API_KEY,
+		});
+		this.conversations = new Map();
+	}
+
+	async logout(conversation) {
+		conversation.auth = new Map();
+	}
+
+	async reset(conversation) {
+		await conversation.flush();
+		await this.resetState(conversation);
+		await this.initConversation(conversation);
+		await conversation.storeState();
+	}
+
+	getModelFromLabel(label) {
+		return this.models.find(model => model.label === label);
+	}
+
+	getModelFromName(name) {
+		return this.models.find(model => model.name === name);
+	}
+
+	async resetState(conversation) {
+		conversation.state = await this.getDefaultState();
+	}
+
+	async getDefaultState() {
+		return {
+			model: 'gpt-3.5-turbo-16k',
+		};
+	}
+
+	addTool(tool) {
+		this.tools.set(tool.name, tool);
+	}
+
+	addMiddleware(middleware) {
+		this.middlewares.set(middleware.name, middleware);
+	}
+
+	async initConversation(conversation) {
+		await this.doInitConversation(conversation);
+		await conversation.storeState();
+	}
+
+	async doInitConversation(conversation) {
+	}
+
+	async getConversation(id, reply = null) {
+		let conversation = this.conversations.get(id);
+		if (!conversation) {
+			conversation = new Conversation(this.name + '-' + id);
+
+			if (!(await conversation.loadState())) {
+				await this.resetState(conversation);
+				await this.initConversation(conversation);
+			}
+
+			this.conversations.set(id, conversation);
+		}
+
+		if (reply)
+			conversation.reply = reply;
+
+		return conversation;
+	}
+
+	async getConversationIfExists(id) {
+		if (this.conversations.has(id))
+			return this.conversations.get(id);
+
+		const conversation = new Conversation(this.name + '-' + id);
+
+		if (await conversation.loadState())
+			return conversation;
+
+		return null;
+	}
+
+	async message(conversation, text) {
+		if (text.startsWith('/')) {
+			const fullCommand = text.trim().split(' ');
+			const command = fullCommand.shift().substring(1);
+			const command_args = fullCommand.length ? fullCommand.join(' ').trim() : null;
+			try {
+				await this.executeCommand(conversation, command, command_args);
+			} catch (e) {
+				await conversation.reply(e.message || e.error || JSON.stringify(e));
+			}
+
+			return;
+		}
+
+		await this.execute(conversation, text);
+	}
+
+	async executeCommand(conversation, name, args) {
+		const command = this.commands.get(name);
+		if (!command)
+			throw new Error('Comando non riconosciuto');
+
+		await command.exec(conversation, args);
+	}
+
+	async execute(conversation, user_message) {
+		for (let middleware of this.middlewares.values()) {
+			let proceed = await middleware.before_add(conversation, user_message);
+			if (!proceed)
+				return;
+		}
+
+		if (user_message) {
+			await this.log('user_message', user_message);
+			conversation.addUserMessage(user_message);
+		}
+
+		if (this.options.memory_handler)
+			conversation = await this.options.memory_handler.handle(conversation);
+
+		for (let middleware of this.middlewares.values()) {
+			let proceed = await middleware.before_exec(conversation, user_message);
+			if (!proceed) {
+				await conversation.storeState();
+				return;
+			}
+		}
+
+		const completion = await this.generateCompletion(conversation);
+
+		await this.handleCompletion(conversation, completion);
+
+		const reversedMiddlewares = [...this.middlewares.values()];
+		reversedMiddlewares.reverse();
+
+		for (let middleware of reversedMiddlewares) {
+			let proceed = await middleware.after_exec(conversation, user_message);
+			if (!proceed)
+				return;
+		}
+	}
+
+	async generateCompletion(conversation, payload = {}, retry_counter = 1) {
+		try {
+			const completion_payload = {
+				model: conversation.state.model,
+				messages: conversation.getMessagesJson(),
+				functions: await this.getFunctions(),
+				...payload,
+			};
+
+			if (!completion_payload.functions?.length) {
+				delete completion_payload.functions;
+				if (completion_payload.hasOwnProperty('function_call'))
+					delete completion_payload.function_call;
+			}
+
+			const chatCompletion = await this.openai.chat.completions.create(completion_payload);
+
+			let completion = chatCompletion.choices[0].message;
+			if (completion.function_call && completion.function_call.arguments)
+				completion.function_call.arguments = JSON.parse(completion.function_call.arguments);
+
+			return completion;
+		} catch (error) {
+			if (error.response) {
+				console.error(error.response.status);
+				console.error(error.response.data);
+
+				if (error.response.status >= 500 && retry_counter <= 5) {
+					await new Promise(resolve => {
+						setTimeout(resolve, 1000);
+					});
+
+					return this.generateCompletion(conversation, payload, retry_counter + 1);
+				}
+
+				await conversation.reply('# Errore ' + error.response.status + ': ' + JSON.stringify(error.response.data));
+			} else if (error.message) {
+				console.error(error.message);
+				await conversation.reply('# Errore ' + error.message);
+			} else {
+				console.error(error);
+				await conversation.reply('# Errore interno');
+			}
+		}
+	}
+
+	async handleCompletion(conversation, completion) {
+		conversation.addAssistantMessage(completion.content, completion.function_call ? {
+			...completion.function_call,
+			arguments: JSON.stringify(completion.function_call.arguments),
+		} : null);
+		if (completion.content) {
+			await this.log('ai_message', completion.content);
+			await conversation.reply(completion.content);
+		}
+
+		if (completion?.function_call)
+			return this.callFunction(conversation, completion.function_call);
+		else
+			return conversation.storeState();
+	}
+
+	async getFunctions(parsed = true) {
+		if (this.functions === null) {
+			this.functions = new Map();
+			for (let tool of this.tools.values()) {
+				let functions = await tool.getFunctions();
+				for (let func of functions) {
+					if (this.functions.has(func.name))
+						throw new Error('Duplicate function ' + func.name + ' in agent');
+
+					this.functions.set(func.name, {
+						tool,
+						function: func,
+					});
+				}
+			}
+		}
+
+		if (parsed)
+			return Array.from(this.functions.values()).map(f => f.function)
+		else
+			return this.functions;
+	}
+
+	async callFunction(conversation, function_call) {
+		let functions = await this.getFunctions(false);
+		if (!functions.has(function_call.name))
+			throw new Error('Unrecognized function ' + function_call.name);
+
+		await this.log('function_call', function_call);
+
+		try {
+			const response = await functions.get(function_call.name).tool.callFunction(conversation, function_call.name, function_call.arguments);
+			conversation.addFunctionMessage(response, function_call.name);
+			await this.log('function_response', response);
+		} catch (error) {
+			conversation.addFunctionMessage({error}, function_call.name);
+			await this.log('function_response', {error});
+		}
+
+		await this.execute(conversation);
+	}
+
+	async log(type, payload) {
+		if (this.options.logger)
+			return this.options.logger.log(this.name, type, payload);
+	}
+
+	async getPromptWordsForTranscription(conversation) {
+		return [this.name];
+	}
+
+	async transcribe(file, conversation) {
+		let words = await this.getPromptWordsForTranscription(conversation);
+
+		let response = await this.openai.audio.transcriptions.create({
+			file,
+			model: 'whisper-1',
+			prompt: words.join(', '),
+		});
+		return response.text;
+	}
+}
+
+export {Agent};

package/Conversation.js

@@ -0,0 +1,87 @@
+import {Message} from "./Message.js";
+import Redis from "@travio/redis";
+
+class Conversation {
+	id;
+	reply;
+	messages = [];
+	state = {};
+	auth = new Map();
+
+	constructor(id) {
+		this.id = id;
+	}
+
+	clone(keepMessages = true) {
+		let newConversation = new Conversation(this.id);
+		newConversation.reply = this.reply;
+		newConversation.state = this.state;
+		if (keepMessages)
+			newConversation.messages = [...this.messages];
+		return newConversation;
+	}
+
+	async flush() {
+		this.messages = [];
+	}
+
+	async loadState() {
+		await this.flush();
+		this.state = {};
+
+		const conv = await Redis.get('conversation-' + this.id);
+		if (conv) {
+			this.auth = new Map(conv.auth || []);
+			this.state = conv.state || {};
+			this.messages = conv.messages.map(m => (new Message(m.role, m.text, m.name, m.function_call, m.tags || [])));
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	async setState(state, save = true) {
+		this.state = {...this.state, ...state};
+		if (save)
+			await this.storeState();
+	}
+
+	async storeState() {
+		await Redis.set('conversation-' + this.id, {
+			auth: [...this.auth.entries()],
+			state: this.state,
+			messages: this.messages,
+		}, 0);
+	}
+
+	getMessagesJson() {
+		return this.messages.map(m => ({
+			role: m.role,
+			content: m.text,
+			name: m.name || undefined,
+			function_call: m.function_call || undefined,
+		}));
+	}
+
+	addSystemMessage(text, tags = []) {
+		this.messages.push(new Message('system', text, null, null, tags));
+	}
+
+	addUserMessage(text, name = null, tags = []) {
+		this.messages.push(new Message('user', text, name, null, tags));
+	}
+
+	addAssistantMessage(text, function_call = null, tags = []) {
+		this.messages.push(new Message('assistant', text, null, function_call, tags));
+	}
+
+	addFunctionMessage(response, name = null, tags = []) {
+		this.messages.push(new Message('function', JSON.stringify(response), name, null, tags));
+	}
+
+	removeMessagesWithTag(tag) {
+		this.messages = this.messages.filter(m => !m.tags.includes(tag));
+	}
+}
+
+export {Conversation};

package/Logger.js

@@ -0,0 +1,17 @@
+class Logger {
+	listeners = [];
+	logs = [];
+
+	subscribe(callback) {
+		this.listeners.push(callback);
+	}
+
+	async log(agent, type, payload) {
+		this.logs.push({agent, type, payload});
+
+		for (let listener of this.listeners)
+			await listener.call(null, agent, type, payload);
+	}
+}
+
+export {Logger};

package/MemoryHandler.js

@@ -0,0 +1,12 @@
+class MemoryHandler {
+	agent = null;
+
+	setAgent(agent) {
+		this.agent = agent;
+	}
+
+	async handle(conversation) {
+	}
+}
+
+export {MemoryHandler};

package/Message.js

@@ -0,0 +1,17 @@
+class Message {
+	role;
+	text;
+	name;
+	function_call;
+	tags = [];
+
+	constructor(role, text, name = null, function_call = null, tags = []) {
+		this.role = role;
+		this.text = text;
+		this.name = name;
+		this.function_call = function_call;
+		this.tags = tags;
+	}
+}
+
+export {Message};

package/Middleware.js

@@ -0,0 +1,22 @@
+class Middleware {
+	name;
+	agent;
+
+	constructor(agent) {
+		this.agent = agent;
+	}
+
+	async before_add(conversation, user_message) {
+		return true;
+	}
+
+	async before_exec(conversation, user_message) {
+		return true;
+	}
+
+	async after_exec(conversation, user_message) {
+		return true;
+	}
+}
+
+export {Middleware};

package/Summarizer.js

@@ -0,0 +1,95 @@
+import {MemoryHandler} from "./MemoryHandler.js";
+import {encoding_for_model} from "tiktoken";
+
+class Summarizer extends MemoryHandler {
+	constructor(threshold = 0.7, summary_length = 0.4) {
+		super();
+		this.threshold = 0.7;
+		this.summary_length = 0.7;
+	}
+
+	async handle(conversation) {
+		const model = this.agent.models.find(model => model.key === conversation.state.model);
+		if (!model)
+			return conversation;
+
+		const encoder = encoding_for_model(model.base_model);
+		const tokens = this.countTokens(encoder, conversation);
+		if (tokens >= model.tokens * this.threshold)
+			return await this.summarize(encoder, conversation, model.tokens * this.summary_length);
+		else
+			return conversation;
+	}
+
+	countTokens(encoder, conversation) {
+		return encoder.encode(conversation.messages.map(m => m.text).join('')).length;
+	}
+
+	async summarize(encoder, conversation, maxLength) {
+		let summaryConversation = conversation.clone(false);
+
+		let currentStep = 'system';
+		for (let message of conversation.messages) {
+			switch (currentStep) {
+				case 'system':
+					if (message.role !== 'system')
+						currentStep = 'summary';
+					break;
+				case 'summary':
+					if (message.role === 'user' && this.hasPassedLimit(encoder, summaryConversation, maxLength)) {
+						summaryConversation = await this.doSummarize(summaryConversation, maxLength);
+						currentStep = 'retain';
+					}
+					break;
+			}
+
+			summaryConversation.messages.push(message);
+		}
+
+		return summaryConversation;
+	}
+
+	hasPassedLimit(encoder, conversation, maxLength) {
+		let length = this.countTokens(encoder, conversation);
+		return length > maxLength;
+	}
+
+	async doSummarize(conversation, maxLength) {
+		conversation.addSystemMessage('Summarize the conversation up to this moment.');
+		const summary = await this.agent.generateCompletion(conversation, {
+			functions: [
+				{
+					name: 'summarize',
+					description: 'Generate a summary of the conversation in ' + Math.round(maxLength / 2) + ' words at most, in a way that it is easy for you to keep track of the important info. Do not omit relevant information you need to remember in order to continue the conversation.',
+					parameters: {
+						type: 'object',
+						properties: {
+							summary: {
+								type: 'string'
+							}
+						},
+						required: ['summary'],
+					}
+				},
+			],
+			function_call: {name: 'summarize'},
+		});
+
+		if (!summary)
+			return false;
+
+		let summarizedConversation = conversation.clone(false);
+		for (let message of conversation.messages) {
+			if (message.role === 'system' && !message.tags.includes('summary')) {
+				summarizedConversation.messages.push(message);
+			} else {
+				summarizedConversation.addSystemMessage("This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
+				break;
+			}
+		}
+
+		return summarizedConversation;
+	}
+}
+
+export {Summarizer};

package/Tool.js

@@ -0,0 +1,13 @@
+class Tool {
+	name = '';
+
+	async getFunctions() {
+		return [];
+	}
+
+	async callFunction(conversation, name, payload) {
+		return {error: 'callFunction is yet to be implemented'};
+	}
+}
+
+export {Tool};

package/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import {Agent} from "./Agent.js";
+import {Conversation} from "./Conversation.js";
+import {Message} from "./Message.js";
+import {Tool} from "./Tool.js";
+import {Logger} from "./Logger.js";
+import {MemoryHandler} from "./MemoryHandler.js";
+import {Middleware} from "./Middleware.js";
+import {Summarizer} from "./Summarizer.js";
+
+export {
+	Agent,
+	Conversation,
+	Message,
+	Tool,
+	Logger,
+	MemoryHandler,
+	Middleware,
+	Summarizer,
+};

package/package.json

@@ -0,0 +1,17 @@
+{
+  "type": "module",
+  "name": "symposium",
+  "version": "0.1.0",
+  "description": "Agents",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Domenico Giambra",
+  "license": "ISC",
+  "dependencies": {
+    "@travio/redis": "^1.3.2",
+    "openai": "^4.12.1",
+    "tiktoken": "^1.0.10"
+  }
+}