symposium 0.15.3 → 0.15.5

package/Agent.js

@@ -123,88 +123,88 @@ export default class Agent {
 	async execute(thread, counter = 0, existing_emitter = null) {
 		const emitter = existing_emitter || new BufferedEventEmitter();
 
-		if (counter === 0)
-			thread = await this.beforeExecute(thread, emitter);
-
-		const model = Symposium.getModelByName(thread.state.model);
+		const execution = new Promise(async (resolve, reject) => {
+			try {
+				if (counter === 0)
+					thread = await this.beforeExecute(thread, emitter);
+
+				const model = Symposium.getModelByName(thread.state.model);
+
+				const completion_options = {};
+				if (this.type === 'utility') {
+					if (['function', 'json'].includes(this.utility.type)) {
+						if (!this.utility.function || !this.utility.function.name || !this.utility.function.parameters)
+							throw new Error('Bad function definition');
+
+						let response_format = null;
+						if (this.utility.type === 'json' && model.supports_structured_output)
+							response_format = this.convertFunctionToResponseFormat(this.utility.function.parameters);
+
+						if (response_format && response_format.count <= 100) { // OpenAI does not support structured output if there are more than 100 parameters
+							completion_options.response_format = {
+								type: 'json_schema',
+								json_schema: {
+									name: this.utility.function.name,
+									schema: response_format.obj,
+									strict: true,
+								},
+							};
+						} else {
+							completion_options.functions = [
+								this.utility.function,
+							];
+							completion_options.force_function = this.utility.function.name;
+						}
+					}
+				}
 
-		const completion_options = {};
-		if (this.type === 'utility') {
-			if (['function', 'json'].includes(this.utility.type)) {
-				if (!this.utility.function || !this.utility.function.name || !this.utility.function.parameters)
-					throw new Error('Bad function definition');
-
-				let response_format = null;
-				if (this.utility.type === 'json' && model.supports_structured_output)
-					response_format = this.convertFunctionToResponseFormat(this.utility.function.parameters);
-
-				if (response_format && response_format.count <= 100) { // OpenAI does not support structured output if there are more than 100 parameters
-					completion_options.response_format = {
-						type: 'json_schema',
-						json_schema: {
-							name: this.utility.function.name,
-							schema: response_format.obj,
-							strict: true,
-						},
-					};
-				} else {
-					completion_options.functions = [
-						this.utility.function,
-					];
-					completion_options.force_function = this.utility.function.name;
+				let completion;
+				try {
+					completion = await this.generateCompletion(thread, completion_options);
+				} catch (e) {
+					console.error(e.message);
+					switch (this.type) {
+						case 'chat':
+							emitter.emit('error', e.message);
+							return resolve(e);
+
+						case 'utility':
+							throw e;
+
+						default:
+							throw new Error('Bad agent type');
+					}
 				}
-			}
-		}
 
-		let completion;
-		try {
-			completion = await this.generateCompletion(thread, completion_options);
-		} catch (e) {
-			console.error(e.message);
-			switch (this.type) {
-				case 'chat':
-					emitter.emit('error', e.message);
-					if (!existing_emitter)
-						emitter.emit('end');
-					return emitter;
-
-				case 'utility':
-					throw e;
-
-				default:
-					throw new Error('Bad agent type');
-			}
-		}
+				try {
+					thread = await this.afterExecute(thread, completion, emitter);
+					const response = await this.handleCompletion(thread, completion, emitter);
 
-		try {
-			thread = await this.afterExecute(thread, completion);
-			const response = await this.handleCompletion(thread, completion, emitter);
-
-			switch (this.type) {
-				case 'utility':
-					if (!existing_emitter)
-						emitter.emit('end');
-					return response;
-
-				case 'chat':
-					if (!existing_emitter) {
-						emitter.on('data', data => {
-							if (data.type === 'response' && data.content.type === 'continue')
-								this.execute(thread, 0, emitter);
-						}, false);
-					}
+					switch (this.type) {
+						case 'utility':
+							return resolve(response);
+
+						case 'chat':
+							if (response.type === 'continue')
+								return this.execute(thread, 0, emitter);
+
+							return resolve(null);
 
-					return emitter;
+						default:
+							throw new Error('Bad agent type');
+					}
+				} catch (e) {
+					console.error(e);
 
-				default:
-					throw new Error('Bad agent type');
+					if (counter < this.max_retries)
+						await this.execute(thread, counter + 1, emitter);
+				}
+			} catch (e) {
+				reject(e);
 			}
-		} catch (e) {
-			console.error(e);
+		});
 
-			if (counter < this.max_retries)
-				await this.execute(thread, counter + 1, emitter);
-		}
+		return this.type === 'chat' ? emitter : execution;
 	}
 
 	convertFunctionToResponseFormat(obj) {
@@ -246,7 +246,7 @@ export default class Agent {
 		};
 	}
 
-	async afterExecute(thread, completion) {
+	async afterExecute(thread, completion, emitter) {
 		return thread;
 	}
 
@@ -315,12 +315,12 @@ export default class Agent {
 					case 'text':
 						if (this.type === 'utility') {
 							if (this.utility.type === 'text')
-								return this.afterHandle(thread, completion, 'return', m.content);
+								return this.afterHandle(thread, completion, m.content);
 							if (this.utility.type === 'json' && model.supports_structured_output)
-								return this.afterHandle(thread, completion, 'return', JSON.parse(m.content));
+								return this.afterHandle(thread, completion, JSON.parse(m.content));
 						}
 
-						emitter.emit('data', {type: 'output', content: m.content});
+						emitter.emit('output', m.content);
 						break;
 
 					case 'function':
@@ -334,7 +334,7 @@ export default class Agent {
 		if (functions.length) {
 			for (let f of functions) {
 				if (this.utility && ['function', 'json'].includes(this.utility.type))
-					return this.afterHandle(thread, completion, 'return', f.arguments);
+					return this.afterHandle(thread, completion, f.arguments);
 
 				const function_response = await this.callFunction(thread, f, emitter);
 
@@ -348,18 +348,15 @@ export default class Agent {
 				await this.log('function_response', function_response);
 			}
 
-			return this.afterHandle(thread, completion, 'continue');
+			return this.afterHandle(thread, completion);
 		} else {
 			await thread.storeState();
-			return this.afterHandle(thread, completion, 'void');
+			return this.afterHandle(thread, completion);
 		}
 	}
 
-	async afterHandle(thread, completion, type, value = null) {
-		return {
-			type,
-			value,
-		};
+	async afterHandle(thread, completion, value = null) {
+		return value;
 	}
 
 	async getFunctions(parsed = true) {
@@ -392,16 +389,16 @@ export default class Agent {
 
 		const func = functions.get(function_call.name);
 		const partialOutput = func.partialOutput ? ((typeof func.partialOutput) === 'text' ? func.partialOutput : func.partialOutput.call(this, function_call.arguments)) : 'Uso lo strumento ' + function_call.name + '...';
-		emitter.emit('data', {type: 'partial', content: partialOutput});
+		emitter.emit('partial', partialOutput);
 
 		await this.log('function_call', function_call);
 
 		try {
 			const response = await func.tool.callFunction(thread, function_call.name, function_call.arguments);
-			emitter.emit('data', {type: 'partial', content: 'Risposta ricevuta da ' + func.tool.name});
+			emitter.emit('partial', 'Risposta ricevuta da ' + func.tool.name);
 			return response;
 		} catch (error) {
-			emitter.emit('data', {type: 'partial', content: 'Ricevuto errore da ' + func.tool.name});
+			emitter.emit('partial', 'Ricevuto errore da ' + func.tool.name);
 			return {error};
 		}
 	}
@@ -423,6 +420,7 @@ export default class Agent {
 		return [this.name];
 	}
 
+	// Currently specific for OpenAI Realtime API
 	async createRealtimeSession(thread_id = null, options = {}) {
 		options = {
 			include_thread: true,
@@ -430,7 +428,7 @@ export default class Agent {
 			...options,
 		};
 
-		// Se viene passato un thread esistente, lo si usa, altrimenti si crea un nuovo thread temporaneo
+		// If a thread is passed, it is used, otherwise a temporary thread is created
 		const thread = await this.getThread(thread_id || uuid());
 
 		const system_message = [], conversation = [];

package/README.md

@@ -82,14 +82,8 @@ async function main() {
 
 	const emitter = await agent.message('Hello, who are you?');
 
-	emitter.on('data', (data) => {
-		if (data.type === 'output') {
-			process.stdout.write(data.content);
-		}
-	});
-
-	emitter.on('end', () => {
-		console.log('\nConversation ended.');
+	emitter.on('output', (content) => {
+		process.stdout.write(content);
 	});
 }
 

package/package.json

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