symposium 0.4.4 → 0.4.6

package/Agent.js

@@ -1,5 +1,6 @@
 import Symposium from "./Symposium.js";
 import Thread from "./Thread.js";
+import Message from "./Message.js";
 
 export default class Agent {
 	name = 'Agent';
@@ -88,7 +89,7 @@ export default class Agent {
 
 	async message(thread, text) {
 		await this.log('user_message', text);
-		thread.addUserMessage(text);
+		thread.addMessage('user', 'text', text);
 
 		await this.execute(thread, text);
 	}
@@ -123,7 +124,16 @@ export default class Agent {
 	async generateCompletion(thread, payload = {}, retry_counter = 1) {
 		try {
 			const model = Symposium.getModelByName(thread.state.model);
-			return model.generate(thread, payload, await this.getFunctions());
+
+			const response = await model.generate(thread, payload, await this.getFunctions());
+			if (!model.supports_functions) {
+				const newMessages = [];
+				for (let message of response.messages)
+					newMessages.concat(...this.parseFunctions(message));
+				response.messages = newMessages;
+			}
+
+			return response;
 		} catch (error) {
 			if (error.response) {
 				console.error(error.response.status);
@@ -148,22 +158,46 @@ export default class Agent {
 		}
 	}
 
-	async handleCompletion(thread, completion) {
-		for (let message of completion.messages) {
-			thread.addMessage(message);
-			await this.log('ai_message', message.text);
-			await thread.reply(message.text);
+	parseFunctions(message) {
+		const messages = [];
+		if (message.type === 'text' && message.content.match(/```\nCALL [A-Za-z0-9_]+\n(\{.+\}\n)?```/)) {
+			const splitted = message.content.split('```');
+			for (let text of splitted) {
+				const match = text.match(/^CALL ([A-Za-z0-9_]+)\n([\s\S]*)$/);
+				if (match)
+					messages.push(new Message(message.role, 'function', {name: match[1], arguments: JSON.parse(match[2] || '{}')}));
+				else
+					messages.push(new Message(message.role, 'text', text.trim()));
+			}
+		} else {
+			messages.push(message);
 		}
 
-		if (completion.function) {
-			thread.addAssistantMessage('', {
-				name: completion.function.name,
-				arguments: JSON.stringify(completion.function_call.args),
-			});
+		return messages;
+	}
+
+	async handleCompletion(thread, completion) {
+		let call_function = null;
+		for (let message of completion.messages) {
+			thread.addDirectMessage(message);
+			await this.log('ai_message', message);
+
+			switch (message.type) {
+				case 'text':
+					await thread.reply(message.content);
+					break;
+
+				case 'function':
+					if (call_function)
+						throw new Error('The model replied with more than one function');
+					else
+						call_function = message.content;
+					break;
+			}
 		}
 
-		if (completion.function)
-			return this.callFunction(thread, completion.function);
+		if (call_function)
+			return this.callFunction(thread, call_function);
 		else
 			return thread.storeState();
 	}
@@ -199,11 +233,11 @@ export default class Agent {
 		await this.log('function_call', function_call);
 
 		try {
-			const response = await functions.get(function_call.name).tool.callFunction(thread, function_call.name, function_call.args);
-			thread.addFunctionMessage(response, function_call.name);
+			const response = await functions.get(function_call.name).tool.callFunction(thread, function_call.name, function_call.arguments);
+			thread.addMessage('function', 'text', JSON.stringify(response), function_call.name);
 			await this.log('function_response', response);
 		} catch (error) {
-			thread.addFunctionMessage({error}, function_call.name);
+			thread.addMessage('function', 'text', JSON.stringify({error}), function_call.name);
 			await this.log('function_response', {error});
 		}
 

package/Message.js

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

package/Model.js

@@ -1,3 +1,5 @@
+import Message from "./Message.js";
+
 export default class Model {
 	type = 'llm';
 	name;
@@ -19,12 +21,14 @@ export default class Model {
 
 	promptFromFunctions(functions) {
 		if (!functions.length)
-			return null;
+			return '';
 
-		let message = "Hai a disposizione le seguenti funzioni, per chiamare una funzione scrivi un messaggio che inizia con CALL nome_funzione e a capo inserisci il JSON con gli argomenti, ad esempio:\n" +
+		let message = "Hai a disposizione alcune funzioni che puoi chiamare per ottenere risposte o compiere azioni. Per chiamare una funzione scrivi un messaggio che inizia con CALL nome_funzione e a capo inserisci il JSON con gli argomenti; delimitando il tutto da 3 caratteri ``` - ad esempio:\n" +
+			"```\n" +
 			"CALL create_user\n" +
-			'{"name":"test"}' + "\n\n" +
-			"Lista funzioni:\n";
+			'{"name":"test"}' + "\n" +
+			"```\n\n" +
+			"Lista delle funzioni che hai a disposizione:\n";
 
 		for (let f of functions)
 			message += '- ' + f.name + "\n " + f.description + "\n";

package/Summarizer.js

@@ -56,7 +56,7 @@ export default class Summarizer extends MemoryHandler {
 	}
 
 	async doSummarize(thread, maxLength) {
-		thread.addSystemMessage('Summarize the conversation up to this moment.');
+		thread.addMessage('system', 'text', 'Summarize the conversation up to this moment.');
 		const summary = await this.agent.generateCompletion(thread, {
 			functions: [
 				{
@@ -84,7 +84,7 @@ export default class Summarizer extends MemoryHandler {
 			if (message.role === 'system' && !message.tags.includes('summary')) {
 				summarizedThread.messages.push(message);
 			} else {
-				summarizedThread.addSystemMessage("This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
+				summarizedThread.addMessage('system', 'text', "This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
 				break;
 			}
 		}

package/Thread.js

@@ -33,7 +33,7 @@ export default class Thread {
 		const conv = await Redis.get('thread-' + this.id);
 		if (conv) {
 			this.state = conv.state || {};
-			this.messages = conv.messages.map(m => (new Message(m.role, m.text, m.name, m.function_call, m.tags || [])));
+			this.messages = conv.messages.map(m => new Message(m.role, m.type, m.content, m.tags));
 			return true;
 		} else {
 			return false;
@@ -53,33 +53,12 @@ export default class Thread {
 		}, 0);
 	}
 
-	getMessagesJson() {
-		return this.messages.map(m => ({
-			role: m.role,
-			content: m.text,
-			name: m.name || undefined,
-			function_call: m.function_call || undefined,
-		}));
-	}
-
-	addMessage(message) {
+	addDirectMessage(message) {
 		this.messages.push(message);
 	}
 
-	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));
+	addMessage(role, type, content, name = null, tags = []) {
+		this.addDirectMessage(new Message(role, type, content, name, tags));
 	}
 
 	removeMessagesWithTag(tag) {

package/models/AnthropicModel.js

@@ -20,7 +20,7 @@ export default class AnthropicModel extends Model {
 		if (functions.length && !this.supports_functions) {
 			// Se il modello non supporta nativamente le funzioni, aggiungo il prompt al messaggio di sistema
 			const functions_prompt = this.promptFromFunctions(functions);
-			system += functions_prompt;
+			system += "\n\n" + functions_prompt;
 			functions = [];
 		}
 
@@ -38,7 +38,7 @@ export default class AnthropicModel extends Model {
 		if (message.content) {
 			for (let m of message.content)
 				// TODO: supporto ad altri tipi oltre a text (m.type)
-				response.messages.push(new Message('assistant', m.text));
+				response.messages.push(new Message('assistant', 'text', m.text));
 		}
 
 		return response;
@@ -46,11 +46,30 @@ export default class AnthropicModel extends Model {
 
 	convertMessages(thread) {
 		let system = [], messages = [];
-		for (let message of thread.getMessagesJson()) {
-			if (message.role === 'system')
+		for (let message of thread.messages) {
+			if (message.role === 'system') {
 				system.push(message.content);
-			else
-				messages.push(message);
+			} else {
+				switch (message.type) {
+					case 'text':
+						messages.push({
+							role: message.role,
+							type: 'text',
+							content: message.content,
+						});
+						break;
+
+					case 'function':
+						messages.push({
+							role: message.role,
+							type: 'text',
+							content: '```CALL \n' + message.content.name + '\n' + JSON.stringify(message.content.arguments || {}) + '\n```',
+						});
+
+					default:
+						throw new Error('Message type unsupported by this model');
+				}
+			}
 		}
 
 		return [system.length ? system.join("\n") : undefined, messages];

package/models/OpenAIModel.js

@@ -15,7 +15,7 @@ export default class OpenAIModel extends Model {
 	}
 
 	async generate(thread, payload = {}, functions = []) {
-		let messages = thread.getMessagesJson();
+		let messages = thread.messages;
 
 		if (functions.length && !this.supports_functions) {
 			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
@@ -31,7 +31,7 @@ export default class OpenAIModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push({role: 'system', content: functions_prompt});
+			system_messages.push(new Message('system', 'text', functions_prompt));
 
 			messages = [...system_messages, ...other_messages];
 			functions = [];
@@ -39,7 +39,7 @@ export default class OpenAIModel extends Model {
 
 		const completion_payload = {
 			model: this.name,
-			messages,
+			messages: messages.map(m => this.convertMessage(m)),
 			functions,
 			...payload,
 		};
@@ -51,19 +51,44 @@ export default class OpenAIModel extends Model {
 		}
 
 		const chatCompletion = await this.getOpenAi().chat.completions.create(completion_payload);
+		const completion = chatCompletion.choices[0].message;
 
 		const response = new Response;
-		const completion = chatCompletion.choices[0].message;
 		if (completion.content)
-			response.messages.push(new Message('assistant', completion.content));
-
-		if (completion.function_call && completion.function_call.arguments) {
-			response.function = {
-				name: completion.function_call.name,
-				args: JSON.parse(completion.function_call.arguments),
-			};
-		}
+			response.messages.push(new Message('assistant', 'text', completion.content));
+		if (completion.function_call && completion.function_call.arguments)
+			response.messages.push(new Message('assistant', 'function', completion.function_call));
 
 		return response;
 	}
+
+	convertMessage(message) {
+		switch (message.type) {
+			case 'text':
+				return {
+					role: message.role,
+					content: message.content,
+					name: message.name,
+				};
+
+			case 'function':
+				if (this.supports_functions) {
+					return {
+						role: message.role,
+						content: null,
+						name: message.name,
+						function_call: message.content,
+					};
+				} else {
+					return {
+						role: message.role,
+						content: message.content,
+						name: message.name,
+					};
+				}
+
+			default:
+				throw new Error('Message type unsupported by this model');
+		}
+	}
 }

package/package.json

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