symposium 0.4.6 → 0.5.0

package/Agent.js

@@ -89,7 +89,7 @@ export default class Agent {
 
 	async message(thread, text) {
 		await this.log('user_message', text);
-		thread.addMessage('user', 'text', text);
+		thread.addMessage('user', text);
 
 		await this.execute(thread, text);
 	}
@@ -124,16 +124,8 @@ export default class Agent {
 	async generateCompletion(thread, payload = {}, retry_counter = 1) {
 		try {
 			const model = Symposium.getModelByName(thread.state.model);
-
-			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;
+			const messages = await model.generate(thread, payload, await this.getFunctions());
+			return messages.map(m => model.supports_functions ? m : this.parseFunctions(m));
 		} catch (error) {
 			if (error.response) {
 				console.error(error.response.status);
@@ -159,40 +151,45 @@ export default class Agent {
 	}
 
 	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()));
+		const newContent = [];
+		for (let m of message.content) {
+			if (m.type === 'text' && m.content.match(/```\nCALL [A-Za-z0-9_]+\n(\{.+\}\n)?```/)) {
+				const splitted = m.content.split('```');
+				for (let text of splitted) {
+					const match = text.match(/^CALL ([A-Za-z0-9_]+)\n([\s\S]*)$/);
+					if (match)
+						m.push({type: 'function', content: {name: match[1], arguments: JSON.parse(match[2] || '{}')}});
+					else
+						m.push({type: 'text', content: text.trim()});
+				}
+			} else {
+				newContent.push(m);
 			}
-		} else {
-			messages.push(message);
 		}
 
-		return messages;
+		message.content = newContent;
+		return message;
 	}
 
 	async handleCompletion(thread, completion) {
 		let call_function = null;
-		for (let message of completion.messages) {
+		for (let message of completion) {
 			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;
+			for (let m of message.content) {
+				switch (m.type) {
+					case 'text':
+						await thread.reply(m.content);
+						break;
+
+					case 'function':
+						if (call_function)
+							throw new Error('The model replied with more than one function');
+						else
+							call_function = m.content;
+						break;
+				}
 			}
 		}
 
@@ -234,10 +231,10 @@ export default class Agent {
 
 		try {
 			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);
+			thread.addMessage('function', JSON.stringify(response), function_call.name);
 			await this.log('function_response', response);
 		} catch (error) {
-			thread.addMessage('function', 'text', JSON.stringify({error}), function_call.name);
+			thread.addMessage('function', JSON.stringify({error}), function_call.name);
 			await this.log('function_response', {error});
 		}
 

package/Message.js

@@ -1,15 +1,25 @@
 export default class Message {
 	role;
-	type;
-	content;
-	name;
+	content = [];
+	name = undefined;
 	tags = [];
 
-	constructor(role, type, content, name = null, tags = []) {
+	constructor(role, content = [], name = undefined, tags = []) {
 		this.role = role;
-		this.type = type;
-		this.content = content;
 		this.name = name;
 		this.tags = tags;
+
+		if (typeof content === 'string') {
+			this.content = [
+				{
+					type: 'text',
+					content,
+				},
+			];
+		} else if (typeof content === 'object') {
+			this.content = Array.isArray(content) ? content : [content];
+		} else {
+			throw new Error('Unrecognized message type');
+		}
 	}
 }

package/Summarizer.js

@@ -56,7 +56,7 @@ export default class Summarizer extends MemoryHandler {
 	}
 
 	async doSummarize(thread, maxLength) {
-		thread.addMessage('system', 'text', 'Summarize the conversation up to this moment.');
+		thread.addMessage('system', 'Summarize the conversation up to this moment.');
 		const summary = await this.agent.generateCompletion(thread, {
 			functions: [
 				{
@@ -79,12 +79,13 @@ export default class Summarizer extends MemoryHandler {
 		if (!summary)
 			return false;
 
+		// TODO: sistemare con nuova interfaccia
 		let summarizedThread = thread.clone(false);
 		for (let message of thread.messages) {
 			if (message.role === 'system' && !message.tags.includes('summary')) {
 				summarizedThread.messages.push(message);
 			} else {
-				summarizedThread.addMessage('system', 'text', "This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
+				summarizedThread.addMessage('system', "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.type, m.content, m.tags));
+			this.messages = conv.messages.map(m => new Message(m.role, m.content, m.name, m.tags));
 			return true;
 		} else {
 			return false;
@@ -57,8 +57,8 @@ export default class Thread {
 		this.messages.push(message);
 	}
 
-	addMessage(role, type, content, name = null, tags = []) {
-		this.addDirectMessage(new Message(role, type, content, name, tags));
+	addMessage(role, content = [], name = undefined, tags = []) {
+		this.addDirectMessage(new Message(role, content, name, tags));
 	}
 
 	removeMessagesWithTag(tag) {

package/models/AnthropicModel.js

@@ -1,6 +1,5 @@
 import Model from "../Model.js";
 import Anthropic from '@anthropic-ai/sdk';
-import Response from "../Response.js";
 import Message from "../Message.js";
 
 export default class AnthropicModel extends Model {
@@ -34,14 +33,23 @@ export default class AnthropicModel extends Model {
 
 		const message = await this.getAnthropic().messages.create(completion_payload);
 
-		const response = new Response;
+		const message_content = [];
 		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', 'text', m.text));
+			for (let m of message.content) {
+				switch (m.type) {
+					case 'text':
+						message_content.push({type: 'text', content: m.text});
+						break;
+
+					default:
+						throw new Error('Unrecognized message type in Anthropic response');
+				}
+			}
 		}
 
-		return response;
+		return [
+			new Message('assistant', message_content),
+		];
 	}
 
 	convertMessages(thread) {
@@ -50,25 +58,27 @@ export default class AnthropicModel extends Model {
 			if (message.role === 'system') {
 				system.push(message.content);
 			} else {
-				switch (message.type) {
-					case 'text':
-						messages.push({
-							role: message.role,
-							type: 'text',
-							content: message.content,
-						});
-						break;
+				messages.push({
+					role: message.role,
+					content: message.content.map(c => {
+						switch (c.type) {
+							case 'text':
+								return {
+									type: 'text',
+									text: c.content,
+								};
 
-					case 'function':
-						messages.push({
-							role: message.role,
-							type: 'text',
-							content: '```CALL \n' + message.content.name + '\n' + JSON.stringify(message.content.arguments || {}) + '\n```',
-						});
+							case 'function':
+								return {
+									type: 'text',
+									text: '```CALL \n' + c.content.name + '\n' + JSON.stringify(c.content.arguments || {}) + '\n```',
+								};
 
-					default:
-						throw new Error('Message type unsupported by this model');
-				}
+							default:
+								throw new Error('Message type "' + c.type + '" unsupported by this model');
+						}
+					}),
+				});
 			}
 		}
 

package/models/OpenAIModel.js

@@ -1,4 +1,3 @@
-import Response from "../Response.js";
 import Model from "../Model.js";
 import OpenAI from "openai";
 import Message from "../Message.js";
@@ -31,15 +30,19 @@ export default class OpenAIModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push(new Message('system', 'text', functions_prompt));
+			system_messages.push(new Message('system', functions_prompt));
 
 			messages = [...system_messages, ...other_messages];
 			functions = [];
 		}
 
+		const convertedMessages = [];
+		for (let m of messages)
+			convertedMessages.push(...this.convertMessage(m));
+
 		const completion_payload = {
 			model: this.name,
-			messages: messages.map(m => this.convertMessage(m)),
+			messages: convertedMessages,
 			functions,
 			...payload,
 		};
@@ -53,42 +56,51 @@ 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 message_content = [];
 		if (completion.content)
-			response.messages.push(new Message('assistant', 'text', completion.content));
+			message_content.push({type: 'text', content: completion.content});
 		if (completion.function_call && completion.function_call.arguments)
-			response.messages.push(new Message('assistant', 'function', completion.function_call));
+			message_content.push({type: 'function', content: completion.function_call});
 
-		return response;
+		return [
+			new Message('assistant', message_content),
+		];
 	}
 
 	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 {
+		const messages = [];
+		for (let c of message.content) {
+			switch (c.type) {
+				case 'text':
+					messages.push({
 						role: message.role,
-						content: message.content,
+						content: c.content,
 						name: message.name,
-					};
-				}
-
-			default:
-				throw new Error('Message type unsupported by this model');
+					});
+					break;
+
+				case 'function':
+					if (this.supports_functions) {
+						messages.push({
+							role: message.role,
+							content: null,
+							name: message.name,
+							function_call: c.content,
+						});
+					} else {
+						messages.push({
+							role: message.role,
+							content: c.content,
+							name: message.name,
+						});
+					}
+					break;
+
+				default:
+					throw new Error('Message type unsupported by this model');
+			}
 		}
+
+		return messages;
 	}
 }

package/package.json

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

package/Response.js

@@ -1,4 +0,0 @@
-export default class Response {
-	messages = [];
-	function = null;
-}