symposium 0.2.1 → 0.3.1

package/Agent.js

@@ -1,15 +1,14 @@
 import Symposium from "./Symposium.js";
-import Conversation from "./Conversation.js";
+import Thread from "./Thread.js";
 
 export default class Agent {
 	name = 'Agent';
 	descriptionForFront = '';
 	options = {};
-	conversations;
+	threads;
 	functions = null;
 	middlewares = new Map();
 	tools = new Map();
-	commands;
 	default_model = 'gpt-4-turbo';
 
 	constructor(options) {
@@ -21,88 +20,23 @@ export default class Agent {
 		if (this.options.memory_handler)
 			this.options.memory_handler.setAgent(this);
 
-		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 = Symposium.getModelByLabel(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" + Symposium.models.map(m => m.label).join("\n"));
-					}
-				} else {
-					const currentModel = Symposium.getModelByName(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.conversations = new Map();
+		this.threads = new Map();
 	}
 
-	async logout(conversation) {
-		conversation.auth = new Map();
+	async logout(thread) {
+		thread.auth = new Map();
 	}
 
-	async reset(conversation) {
-		await conversation.flush();
-		await this.resetState(conversation);
-		await this.initConversation(conversation);
-		await conversation.storeState();
+	async reset(thread) {
+		await thread.flush();
+		await this.resetState(thread);
+		await this.initThread(thread);
+		await thread.storeState();
 	}
 
-	async resetState(conversation) {
-		conversation.state = await this.getDefaultState();
-		conversation.state.model = Symposium.getModelByLabel(this.default_model).name;
+	async resetState(thread) {
+		thread.state = await this.getDefaultState();
+		thread.state.model = Symposium.getModelByLabel(this.default_model).name;
 	}
 
 	async getDefaultState() {
@@ -117,89 +51,60 @@ export default class Agent {
 		this.middlewares.set(middleware.name, middleware);
 	}
 
-	async initConversation(conversation) {
-		await this.doInitConversation(conversation);
-		await conversation.storeState();
+	async initThread(thread) {
+		await this.doInitThread(thread);
+		await thread.storeState();
 	}
 
-	async doInitConversation(conversation) {
+	async doInitThread(thread) {
 	}
 
-	async getConversation(id, reply = null) {
-		let conversation = this.conversations.get(id);
-		if (!conversation) {
-			conversation = new Conversation(this.name + '-' + id);
+	async getThread(id, reply = null) {
+		let thread = this.threads.get(id);
+		if (!thread) {
+			thread = new Thread(this.name + '-' + id);
 
-			if (!(await conversation.loadState())) {
-				await this.resetState(conversation);
-				await this.initConversation(conversation);
+			if (!(await thread.loadState())) {
+				await this.resetState(thread);
+				await this.initThread(thread);
 			}
 
-			this.conversations.set(id, conversation);
+			this.threads.set(id, thread);
 		}
 
 		if (reply)
-			conversation.reply = reply;
+			thread.reply = reply;
 
-		return conversation;
+		return thread;
 	}
 
-	async getConversationIfExists(id) {
-		if (this.conversations.has(id))
-			return this.conversations.get(id);
+	async getThreadIfExists(id) {
+		if (this.threads.has(id))
+			return this.threads.get(id);
 
-		const conversation = new Conversation(this.name + '-' + id);
+		const thread = new Thread(this.name + '-' + id);
 
-		if (await conversation.loadState())
-			return conversation;
+		if (await thread.loadState())
+			return thread;
 
 		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');
+	async message(thread, text) {
+		await this.log('user_message', text);
+		thread.addUserMessage(text);
 
-		await command.exec(conversation, args);
+		await this.execute(thread, text);
 	}
 
-	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);
-		}
-
+	async execute(thread) {
 		if (this.options.memory_handler)
-			conversation = await this.options.memory_handler.handle(conversation);
+			thread = await this.options.memory_handler.handle(thread);
 
 		for (let middleware of this.middlewares.values()) {
-			let proceed = await middleware.before_exec(conversation, user_message);
+			let proceed = await middleware.before_exec(thread);
 			if (!proceed) {
-				await conversation.storeState();
+				await thread.storeState();
 				return;
 			}
 		}
@@ -210,25 +115,25 @@ export default class Agent {
 			completion_payload.function_call = {name: this.options.talking_function.name};
 		}
 
-		const completion = await this.generateCompletion(conversation, completion_payload);
+		const completion = await this.generateCompletion(thread, completion_payload);
 
-		await this.handleCompletion(conversation, completion);
+		await this.handleCompletion(thread, completion);
 
 		const reversedMiddlewares = [...this.middlewares.values()];
 		reversedMiddlewares.reverse();
 
 		for (let middleware of reversedMiddlewares) {
-			let proceed = await middleware.after_exec(conversation, user_message);
+			let proceed = await middleware.after_exec(thread);
 			if (!proceed)
 				return;
 		}
 	}
 
-	async generateCompletion(conversation, payload = {}, retry_counter = 1) {
+	async generateCompletion(thread, payload = {}, retry_counter = 1) {
 		try {
 			const completion_payload = {
-				model: conversation.state.model,
-				messages: conversation.getMessagesJson(),
+				model: thread.state.model,
+				messages: thread.getMessagesJson(),
 				functions: await this.getFunctions(),
 				...payload,
 			};
@@ -257,42 +162,42 @@ export default class Agent {
 						setTimeout(resolve, 1000);
 					});
 
-					return this.generateCompletion(conversation, payload, retry_counter + 1);
+					return this.generateCompletion(thread, payload, retry_counter + 1);
 				}
 
-				await conversation.reply('# Errore ' + error.response.status + ': ' + JSON.stringify(error.response.data));
+				await thread.reply('# Errore ' + error.response.status + ': ' + JSON.stringify(error.response.data));
 			} else if (error.message) {
 				console.error(error.message);
-				await conversation.reply('# Errore ' + error.message);
+				await thread.reply('# Errore ' + error.message);
 			} else {
 				console.error(error);
-				await conversation.reply('# Errore interno');
+				await thread.reply('# Errore interno');
 			}
 		}
 	}
 
-	async handleCompletion(conversation, completion) {
+	async handleCompletion(thread, completion) {
 		if (this.options.talking_function && completion.function_call) {
 			const text = completion.function_call.arguments[Object.keys(this.options.talking_function.parameters.properties)[0]];
-			conversation.addAssistantMessage(text);
+			thread.addAssistantMessage(text);
 			await this.log('ai_message', text);
-			await conversation.reply(text);
-			return conversation.storeState()
+			await thread.reply(text);
+			return thread.storeState()
 		}
 
-		conversation.addAssistantMessage(completion.content, completion.function_call ? {
+		thread.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);
+			await thread.reply(completion.content);
 		}
 
 		if (completion?.function_call)
-			return this.callFunction(conversation, completion.function_call);
+			return this.callFunction(thread, completion.function_call);
 		else
-			return conversation.storeState();
+			return thread.storeState();
 	}
 
 	async getFunctions(parsed = true) {
@@ -318,7 +223,7 @@ export default class Agent {
 			return this.functions;
 	}
 
-	async callFunction(conversation, function_call) {
+	async callFunction(thread, function_call) {
 		let functions = await this.getFunctions(false);
 		if (!functions.has(function_call.name))
 			throw new Error('Unrecognized function ' + function_call.name);
@@ -326,15 +231,15 @@ export default class Agent {
 		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);
+			const response = await functions.get(function_call.name).tool.callFunction(thread, function_call.name, function_call.arguments);
+			thread.addFunctionMessage(response, function_call.name);
 			await this.log('function_response', response);
 		} catch (error) {
-			conversation.addFunctionMessage({error}, function_call.name);
+			thread.addFunctionMessage({error}, function_call.name);
 			await this.log('function_response', {error});
 		}
 
-		await this.execute(conversation);
+		await this.execute(thread);
 	}
 
 	async log(type, payload) {
@@ -342,7 +247,7 @@ export default class Agent {
 			return this.options.logger.log(this.name, type, payload);
 	}
 
-	async getPromptWordsForTranscription(conversation) {
+	async getPromptWordsForTranscription(thread) {
 		return [this.name];
 	}
 }

package/MemoryHandler.js

@@ -5,6 +5,6 @@ export default class MemoryHandler {
 		this.agent = agent;
 	}
 
-	async handle(conversation) {
+	async handle(thread) {
 	}
 }

package/Middleware.js

@@ -6,15 +6,11 @@ export default class Middleware {
 		this.agent = agent;
 	}
 
-	async before_add(conversation, user_message) {
+	async before_exec(thread) {
 		return true;
 	}
 
-	async before_exec(conversation, user_message) {
-		return true;
-	}
-
-	async after_exec(conversation, user_message) {
+	async after_exec(thread) {
 		return true;
 	}
 }

package/Summarizer.js

@@ -9,55 +9,55 @@ export default class Summarizer extends MemoryHandler {
 		this.summary_length = summary_length;
 	}
 
-	async handle(conversation) {
-		const model = Symposium.getModelByName(conversation.state.model);
+	async handle(thread) {
+		const model = Symposium.getModelByName(thread.state.model);
 		if (!model)
-			return conversation;
+			return thread;
 
 		const encoder = encoding_for_model(model.name_for_tiktoken);
-		const tokens = this.countTokens(encoder, conversation);
+		const tokens = this.countTokens(encoder, thread);
 		if (tokens >= model.tokens * this.threshold)
-			return await this.summarize(encoder, conversation, model.tokens * this.summary_length);
+			return await this.summarize(encoder, thread, model.tokens * this.summary_length);
 		else
-			return conversation;
+			return thread;
 	}
 
-	countTokens(encoder, conversation) {
-		return encoder.encode(conversation.messages.map(m => m.text).join('')).length;
+	countTokens(encoder, thread) {
+		return encoder.encode(thread.messages.map(m => m.text).join('')).length;
 	}
 
-	async summarize(encoder, conversation, maxLength) {
-		let summaryConversation = conversation.clone(false);
+	async summarize(encoder, thread, maxLength) {
+		let summaryThread = thread.clone(false);
 
 		let currentStep = 'system';
-		for (let message of conversation.messages) {
+		for (let message of thread.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);
+					if (message.role === 'user' && this.hasPassedLimit(encoder, summaryThread, maxLength)) {
+						summaryThread = await this.doSummarize(summaryThread, maxLength);
 						currentStep = 'retain';
 					}
 					break;
 			}
 
-			summaryConversation.messages.push(message);
+			summaryThread.messages.push(message);
 		}
 
-		return summaryConversation;
+		return summaryThread;
 	}
 
-	hasPassedLimit(encoder, conversation, maxLength) {
-		let length = this.countTokens(encoder, conversation);
+	hasPassedLimit(encoder, thread, maxLength) {
+		let length = this.countTokens(encoder, thread);
 		return length > maxLength;
 	}
 
-	async doSummarize(conversation, maxLength) {
-		conversation.addSystemMessage('Summarize the conversation up to this moment.');
-		const summary = await this.agent.generateCompletion(conversation, {
+	async doSummarize(thread, maxLength) {
+		thread.addSystemMessage('Summarize the conversation up to this moment.');
+		const summary = await this.agent.generateCompletion(thread, {
 			functions: [
 				{
 					name: 'summarize',
@@ -79,16 +79,16 @@ export default class Summarizer extends MemoryHandler {
 		if (!summary)
 			return false;
 
-		let summarizedConversation = conversation.clone(false);
-		for (let message of conversation.messages) {
+		let summarizedThread = thread.clone(false);
+		for (let message of thread.messages) {
 			if (message.role === 'system' && !message.tags.includes('summary')) {
-				summarizedConversation.messages.push(message);
+				summarizedThread.messages.push(message);
 			} else {
-				summarizedConversation.addSystemMessage("This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
+				summarizedThread.addSystemMessage("This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
 				break;
 			}
 		}
 
-		return summarizedConversation;
+		return summarizedThread;
 	}
 }

package/Symposium.js

@@ -34,14 +34,14 @@ export default class Symposium {
 		return this.models.find(model => model.name === name);
 	}
 
-	static async transcribe(agent, file, conversation) {
-		let words = await agent.getPromptWordsForTranscription(conversation);
+	static async transcribe(agent, file, thread) {
+		const words = await agent.getPromptWordsForTranscription(thread);
 
-		let response = await this.openai.audio.transcriptions.create({
+		const response = await this.getOpenAi().then(openai => openai.audio.transcriptions.create({
 			file,
 			model: 'whisper-1',
 			prompt: words.join(', '),
-		});
+		}));
 		return response.text;
 	}
 }

package/{Conversation.js → Thread.js}

@@ -1,7 +1,7 @@
 import Message from "./Message.js";
 import Redis from "@travio/redis";
 
-export default class Conversation {
+export default class Thread {
 	id;
 	reply;
 	messages = [];
@@ -13,12 +13,12 @@ export default class Conversation {
 	}
 
 	clone(keepMessages = true) {
-		let newConversation = new Conversation(this.id);
-		newConversation.reply = this.reply;
-		newConversation.state = this.state;
+		let newThread = new Thread(this.id);
+		newThread.reply = this.reply;
+		newThread.state = this.state;
 		if (keepMessages)
-			newConversation.messages = [...this.messages];
-		return newConversation;
+			newThread.messages = [...this.messages];
+		return newThread;
 	}
 
 	async flush() {
@@ -29,7 +29,7 @@ export default class Conversation {
 		await this.flush();
 		this.state = {};
 
-		const conv = await Redis.get('conversation-' + this.id);
+		const conv = await Redis.get('thread-' + this.id);
 		if (conv) {
 			this.auth = new Map(conv.auth || []);
 			this.state = conv.state || {};
@@ -47,7 +47,7 @@ export default class Conversation {
 	}
 
 	async storeState() {
-		await Redis.set('conversation-' + this.id, {
+		await Redis.set('thread-' + this.id, {
 			auth: [...this.auth.entries()],
 			state: this.state,
 			messages: this.messages,

package/Tool.js

@@ -5,7 +5,7 @@ export default class Tool {
 		return [];
 	}
 
-	async callFunction(conversation, name, payload) {
+	async callFunction(thread, name, payload) {
 		return {error: 'callFunction is yet to be implemented'};
 	}
 }

package/index.js

@@ -2,7 +2,7 @@
 
 import Symposium from "./Symposium.js";
 import Agent from "./Agent.js";
-import Conversation from "./Conversation.js";
+import Thread from "./Thread.js";
 import Message from "./Message.js";
 import Tool from "./Tool.js";
 import Logger from "./Logger.js";
@@ -13,7 +13,7 @@ import Summarizer from "./Summarizer.js";
 export {
 	Symposium,
 	Agent,
-	Conversation,
+	Thread,
 	Message,
 	Tool,
 	Logger,

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "symposium",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",