symposium 1.2.9 → 1.2.11

package/Agent.js

@@ -292,8 +292,9 @@ export default class Agent {
 			} catch (e) {
 				reject(e);
 			}
-		}).then(() => {
+		}).then(value => {
 			emitter.emit('end', thread);
+			return value;
 		});
 
 		return this.type === 'chat' ? emitter : execution;
@@ -418,20 +419,25 @@ export default class Agent {
 		}
 
 		if (functions.length) {
-			for (let f of functions) {
-				if (this.utility && ['function', 'json'].includes(this.utility.type))
-					return {type: 'response', value: this.afterHandle(thread, completion, f.arguments)};
+			if (this.utility && ['function', 'json'].includes(this.utility.type))
+				return {type: 'response', value: this.afterHandle(thread, completion, functions[0].arguments)};
 
-				const function_response = await this.callFunction(thread, f, emitter);
+			const responses = await Promise.all(functions.map(async f => this.callFunction(thread, f, emitter)));
 
+			if (responses.some(r => r.type === 'tool_auth')) {
+				emitter.emit('tool_auth', responses.filter(r => r.type === 'tool_auth').map(r => ({tool: r.tool, arguments: r.arguments})));
+				return {type: 'void'};
+			}
+
+			for (let r of responses) {
 				thread.addMessage('tool', [
 					{
 						type: 'function_response',
-						content: {name: f.name, response: function_response, id: f.id || undefined},
+						content: {name: f.name, response: r, id: f.id || undefined},
 					},
 				], f.name);
 
-				await this.log('function_response', function_response);
+				await this.log('function_response', r);
 			}
 
 			await this.afterHandle(thread, completion);
@@ -480,19 +486,35 @@ export default class Agent {
 			throw new Error('Unrecognized function ' + function_call.name);
 
 		const func = functions.get(function_call.name);
-		await this.log('function_call', function_call);
 
+		await this.log('function_call', function_call);
 		emitter.emit('tool', function_call);
 
+		if (!func.tool.authorize(thread, function_call.name, function_call.arguments)) {
+			return {
+				type: 'tool_auth',
+				tool: function_call.name,
+				arguments: function_call.arguments,
+			};
+		}
+
 		try {
 			const response = await func.tool.callFunction(thread, function_call.name, function_call.arguments);
 			if (emitter)
 				emitter.emit('tool_response', {name: func.tool.name, success: true, response});
-			return response;
+
+			return {
+				type: 'response',
+				response,
+			};
 		} catch (error) {
 			if (emitter)
 				emitter.emit('tool_response', {name: func.tool.name, success: false, error: error.message || error});
-			return {error};
+
+			return {
+				type: 'error',
+				error,
+			};
 		}
 	}
 

package/Tool.js

@@ -8,4 +8,8 @@ export default class Tool {
 	async callFunction(thread, name, payload) {
 		return {error: 'callFunction is yet to be implemented'};
 	}
+
+	async authorize(thread, name, payload) {
+		return true;
+	}
 }

package/package.json

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