symposium 0.4.5 → 0.4.7

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);
 
 		await this.execute(thread, text);
 	}
@@ -123,7 +124,8 @@ 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 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);
@@ -148,22 +150,51 @@ 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 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);
+			}
 		}
 
-		if (completion.function) {
-			thread.addAssistantMessage('', {
-				name: completion.function.name,
-				arguments: JSON.stringify(completion.function_call.args),
-			});
+		message.content = newContent;
+		return message;
+	}
+
+	async handleCompletion(thread, completion) {
+		let call_function = null;
+		for (let message of completion) {
+			thread.addDirectMessage(message);
+			await this.log('ai_message', message);
+
+			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;
+				}
+			}
 		}
 
-		if (completion.function)
-			return this.callFunction(thread, completion.function);
+		if (call_function)
+			return this.callFunction(thread, call_function);
 		else
 			return thread.storeState();
 	}
@@ -199,11 +230,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', JSON.stringify(response), function_call.name);
 			await this.log('function_response', response);
 		} catch (error) {
-			thread.addFunctionMessage({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;
-	text;
-	name;
-	function_call;
+	content = [];
+	name = undefined;
 	tags = [];
 
-	constructor(role, text, name = null, function_call = null, tags = []) {
+	constructor(role, content = [], name = undefined, tags = []) {
 		this.role = role;
-		this.text = text;
 		this.name = name;
-		this.function_call = function_call;
 		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/Model.js

@@ -1,3 +1,5 @@
+import Message from "./Message.js";
+
 export default class Model {
 	type = 'llm';
 	name;

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', '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.addSystemMessage("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.text, m.name, m.function_call, m.tags || [])));
+			this.messages = conv.messages.map(m => new Message(m.role, 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, 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,23 +33,51 @@ 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', 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) {
 		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

@@ -1,4 +1,3 @@
-import Response from "../Response.js";
 import Model from "../Model.js";
 import OpenAI from "openai";
 import Message from "../Message.js";
@@ -15,7 +14,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 +30,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', functions_prompt));
 
 			messages = [...system_messages, ...other_messages];
 			functions = [];
@@ -39,7 +38,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 +50,46 @@ export default class OpenAIModel extends Model {
 		}
 
 		const chatCompletion = await this.getOpenAi().chat.completions.create(completion_payload);
-
-		const response = new Response;
 		const completion = chatCompletion.choices[0].message;
+
+		const message_content = [];
 		if (completion.content)
-			response.messages.push(new Message('assistant', completion.content));
+			message_content.push({type: 'text', content: completion.content});
+		if (completion.function_call && completion.function_call.arguments)
+			message_content.push({type: 'function', content: completion.function_call});
 
-		if (completion.function_call && completion.function_call.arguments) {
-			response.function = {
-				name: completion.function_call.name,
-				args: JSON.parse(completion.function_call.arguments),
-			};
-		}
+		return [
+			new Message('assistant', message_content),
+		];
+	}
 
-		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.5",
+  "version": "0.4.7",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",

package/Response.js

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