symposium 2.4.3 → 3.0.1

package/Agent.js

@@ -1,26 +1,76 @@
 import {v7 as uuid} from 'uuid';
 
-import BufferedEventEmitter from "./BufferedEventEmitter.js";
-
 import Symposium from "./Symposium.js";
 import Thread from "./Thread.js";
-import Tool from "./Tool.js";
+import Toolkit from "./Toolkit.js";
 import Context from "./Context.js";
 import Text from "./Contexts/Text.js";
-import GetContextTool from "./GetContextTool.js";
+import GetContextToolkit from "./GetContextToolkit.js";
+import MCPServer from "./MCPServer.js";
+import MCPResource from "./Contexts/MCPResource.js";
+
+const CONTROL_TYPES = new Set(['submit', 'cancel', 'auth']);
+
+function isControlMessage(item) {
+	if (!item || typeof item !== 'object' || Array.isArray(item))
+		return false;
+	if (typeof item.type !== 'string')
+		return false;
+	return CONTROL_TYPES.has(item.type);
+}
+
+function isAsyncIterableInput(content) {
+	return content !== null
+		&& typeof content === 'object'
+		&& !Array.isArray(content)
+		&& typeof content[Symbol.asyncIterator] === 'function';
+}
+
+function normalizeStreamBuffer(items) {
+	const blocks = [];
+	for (const item of items) {
+		if (typeof item === 'string')
+			blocks.push({type: 'text', content: item});
+		else if (Array.isArray(item))
+			blocks.push(...item);
+		else if (item && typeof item === 'object')
+			blocks.push(item);
+	}
+	return blocks;
+}
+
+function makeNotifier() {
+	let resolve;
+	let promise = new Promise(r => { resolve = r; });
+	return {
+		wait() { return promise; },
+		signal() {
+			const r = resolve;
+			promise = new Promise(res => { resolve = res; });
+			r();
+		},
+	};
+}
+
+async function isPromiseReady(p) {
+	return Promise.race([
+		p.then(() => true, () => true),
+		new Promise(r => setImmediate(() => r(false))),
+	]);
+}
 
 export default class Agent {
 	name = 'Agent';
 	description = null;
 	options = {};
 	threads;
-	functions = null;
-	tools = new Map();
+	tools = null;
+	toolkits = new Map();
 	context = [];
 	default_model = 'gpt-4o';
 	max_retries = 5;
 	type = 'chat'; // chat, utility
-	utility = null;
+	response_schema = null; // raw JSON schema; when set, final assistant message is parsed against it
 	initialized = false;
 	enable_image_generation = false;
 
@@ -31,6 +81,7 @@ export default class Agent {
 		};
 
 		this.threads = new Map();
+		this._streamingInputs = new Map();
 	}
 
 	async init() {
@@ -40,11 +91,11 @@ export default class Agent {
 		if (this.options.memory_handler)
 			this.options.memory_handler.setAgent(this);
 
-		if (this.type === 'utility') {
-			if (!this.utility || !this.utility.type)
-				throw new Error('Utility function not defined');
-			if (!['text', 'function', 'json'].includes(this.utility.type))
-				throw new Error('Bad utility definition');
+		if (this.response_schema !== null) {
+			if (typeof this.response_schema !== 'object' || Array.isArray(this.response_schema))
+				throw new Error('response_schema must be a JSON schema object');
+			if (typeof this.response_schema.type !== 'string')
+				throw new Error('response_schema must declare a top-level "type"');
 		}
 
 		this.initialized = true;
@@ -66,14 +117,14 @@ export default class Agent {
 		return {};
 	}
 
-	async addTool(tool) {
-		if (!(tool instanceof Tool) || !tool.name)
-			throw new Error('Tool must be an instance of Tool class');
-		if (this.tools.has(tool.name))
-			throw new Error('Tool with name ' + tool.name + ' already exists in agent');
+	async addToolkit(toolkit) {
+		if (!(toolkit instanceof Toolkit) || !toolkit.name)
+			throw new Error('Toolkit must be an instance of Toolkit class');
+		if (this.toolkits.has(toolkit.name))
+			throw new Error('Toolkit with name ' + toolkit.name + ' already exists in agent');
 
-		await tool.init(this);
-		this.tools.set(tool.name, tool);
+		await toolkit.init(this);
+		this.toolkits.set(toolkit.name, toolkit);
 	}
 
 	async addContext(context, options = {}) {
@@ -95,6 +146,23 @@ export default class Agent {
 		this.context.push({title, context, options});
 	}
 
+	async addMCPServer(config) {
+		const server = new MCPServer(config);
+		await this.addToolkit(server);
+
+		if (config.resources) {
+			const resources = await server.listResources();
+			for (const res of resources) {
+				await this.addContext(new MCPResource(server, res), {
+					type: 'on_request',
+					description: res.description || '',
+				});
+			}
+		}
+
+		return server;
+	}
+
 	async initThread(thread) {
 		await this.doInitThread(thread);
 
@@ -121,8 +189,8 @@ export default class Agent {
 			let context_string = context_texts.join('\n\n');
 			if (is_there_on_request) {
 				context_string = '<important>Some of the context files are available to you immediately here, while longer texts may be available only on request; you are provided with a title and a description of these files. If you think it may be useful for your current task, you can request the text via the get_context tool - IMPORTANT: use the title of the file verbatim as it is provided</important>' + context_string;
-				if (!this.tools.has('get_context'))
-					await this.addTool(new GetContextTool(this));
+				if (!this.toolkits.has('get_context'))
+					await this.addToolkit(new GetContextToolkit(this));
 			}
 			context_string = `<context_info>
 ${context_string}
@@ -165,7 +233,22 @@ ${context_string}
 		return thread;
 	}
 
-	async message(content, thread = null) {
+	message(content, thread = null) {
+		if (this.type === 'utility')
+			return this._messageAsValue(content, thread);
+		return this._messageAsStream(content, thread);
+	}
+
+	async _messageAsValue(content, thread) {
+		let value;
+		for await (const ev of this._messageAsStream(content, thread)) {
+			if (ev.type === 'result')
+				value = ev.value;
+		}
+		return value;
+	}
+
+	async *_messageAsStream(content, thread = null) {
 		if (!this.initialized)
 			throw new Error('Agent not initialized');
 
@@ -174,24 +257,221 @@ ${context_string}
 		if (typeof thread !== 'object')
 			thread = await this.getThread(thread);
 
+		if (!isAsyncIterableInput(content)) {
+			const model = Symposium.getModel(thread.state.model);
+			if (!model.audio && typeof content !== 'string') {
+				for (let c of content) {
+					if (c.type === 'audio' && !c.content?.transcription) {
+						const words = await this.getPromptWordsForTranscription(thread);
+						const prompt = words.length ? 'Possibili parole usate: ' + words.join(', ') : null;
+						c.content.transcription = await Symposium.transcribe(c.content, prompt);
+					}
+				}
+			}
+
+			await this.log('user_message', content);
+			thread.addMessage('user', content);
+
+			yield* this.trigger(thread);
+			return;
+		}
+
+		const iterator = content[Symbol.asyncIterator]();
+		const notifier = makeNotifier();
+		const pendingMessages = [];
+		const pendingAuthResponses = new Map();
+		const controlFlags = {cancelled: false, readerFinished: false};
+		const inputState = {streaming: true, pendingMessages, pendingAuthResponses, controlFlags, notifier};
+		this._streamingInputs.set(thread.unique, inputState);
+
+		let readerPromise = Promise.resolve();
+		let readerStarted = false;
+
+		try {
+			const {buffer, iteratorClosed, leftoverNext} = await this._drainInitialInput(iterator, controlFlags);
+
+			if (controlFlags.cancelled) {
+				yield {type: 'start', thread};
+				yield {type: 'end', thread};
+				return;
+			}
+
+			if (buffer.length === 0 && iteratorClosed) {
+				yield {type: 'start', thread};
+				yield {type: 'end', thread};
+				return;
+			}
+
+			const initialContent = normalizeStreamBuffer(buffer);
+			await this._transcribeAudioIfNeeded(thread, initialContent);
+
+			await this.log('user_message', initialContent);
+			thread.addMessage('user', initialContent);
+
+			if (!iteratorClosed) {
+				readerStarted = true;
+				readerPromise = this._runBackgroundReader(iterator, leftoverNext, inputState);
+			} else {
+				controlFlags.readerFinished = true;
+			}
+
+			yield* this.trigger(thread);
+		} finally {
+			this._streamingInputs.delete(thread.unique);
+			if (readerStarted) {
+				try {
+					if (typeof iterator.return === 'function')
+						await iterator.return();
+				} catch (e) {}
+				try {
+					await readerPromise;
+				} catch (e) {}
+			}
+		}
+	}
+
+	async _transcribeAudioIfNeeded(thread, blocks) {
 		const model = Symposium.getModel(thread.state.model);
-		if (!model.audio && typeof content !== 'string') {
-			for (let c of content) {
-				if (c.type === 'audio' && !c.content?.transcription) {
-					const words = await this.getPromptWordsForTranscription(thread);
-					const prompt = words.length ? 'Possibili parole usate: ' + words.join(', ') : null;
-					c.content.transcription = await Symposium.transcribe(c.content, prompt);
+		if (model.audio)
+			return;
+		for (let c of blocks) {
+			if (c?.type === 'audio' && !c.content?.transcription) {
+				const words = await this.getPromptWordsForTranscription(thread);
+				const prompt = words.length ? 'Possibili parole usate: ' + words.join(', ') : null;
+				c.content.transcription = await Symposium.transcribe(c.content, prompt);
+			}
+		}
+	}
+
+	async _drainInitialInput(iterator, controlFlags) {
+		const buffer = [];
+		let iteratorClosed = false;
+		let nextPromise = iterator.next();
+
+		while (true) {
+			if (buffer.length > 0) {
+				const ready = await isPromiseReady(nextPromise);
+				if (!ready)
+					break;
+			}
+
+			let result;
+			try {
+				result = await nextPromise;
+			} catch (e) {
+				iteratorClosed = true;
+				nextPromise = null;
+				throw e;
+			}
+
+			if (result.done) {
+				iteratorClosed = true;
+				nextPromise = null;
+				break;
+			}
+
+			const item = result.value;
+			if (isControlMessage(item)) {
+				if (item.type === 'submit') {
+					nextPromise = iterator.next();
+					break;
+				}
+				if (item.type === 'cancel') {
+					controlFlags.cancelled = true;
+					iteratorClosed = true;
+					nextPromise = null;
+					break;
 				}
+				nextPromise = iterator.next();
+				continue;
 			}
+
+			buffer.push(item);
+			nextPromise = iterator.next();
 		}
 
+		return {buffer, iteratorClosed, leftoverNext: nextPromise};
+	}
+
+	async _runBackgroundReader(iterator, leftoverNext, inputState) {
+		const {pendingMessages, controlFlags, notifier} = inputState;
+		try {
+			let pending = leftoverNext;
+			while (true) {
+				const result = await (pending || iterator.next());
+				pending = null;
+				if (result.done)
+					return;
+				const item = result.value;
+				if (isControlMessage(item)) {
+					if (item.type === 'cancel') {
+						controlFlags.cancelled = true;
+						notifier.signal();
+						return;
+					}
+					if (item.type === 'auth' && item.id) {
+						inputState.pendingAuthResponses.set(item.id, item.decision);
+						notifier.signal();
+						continue;
+					}
+					continue;
+				}
+				pendingMessages.push(item);
+				notifier.signal();
+			}
+		} finally {
+			controlFlags.readerFinished = true;
+			notifier.signal();
+		}
+	}
+
+	async _drainPendingMessages(thread) {
+		const state = this._streamingInputs.get(thread.unique);
+		if (!state || !state.pendingMessages.length)
+			return;
+		const items = state.pendingMessages.splice(0);
+		const content = normalizeStreamBuffer(items);
+		await this._transcribeAudioIfNeeded(thread, content);
 		await this.log('user_message', content);
 		thread.addMessage('user', content);
+	}
 
-		return this.trigger(thread);
+	async _awaitNextStreamingInput(thread) {
+		const state = this._streamingInputs.get(thread.unique);
+		if (!state)
+			return false;
+		while (true) {
+			if (state.controlFlags.cancelled)
+				return false;
+			if (state.pendingMessages.length)
+				return true;
+			if (state.controlFlags.readerFinished)
+				return false;
+			await state.notifier.wait();
+		}
 	}
 
-	async trigger(thread = null) {
+	async _awaitAuthDecision(thread, id) {
+		const state = this._streamingInputs.get(thread.unique);
+		if (!state)
+			return 'reject';
+		while (true) {
+			if (state.pendingAuthResponses.has(id)) {
+				const decision = state.pendingAuthResponses.get(id);
+				state.pendingAuthResponses.delete(id);
+				return decision;
+			}
+			if (state.controlFlags.cancelled)
+				return 'reject';
+			if (state.controlFlags.readerFinished) {
+				state.controlFlags.cancelled = true;
+				return 'reject';
+			}
+			await state.notifier.wait();
+		}
+	}
+
+	async *trigger(thread = null) {
 		if (!this.initialized)
 			throw new Error('Agent not initialized');
 
@@ -200,119 +480,130 @@ ${context_string}
 		if (typeof thread !== 'object')
 			thread = await this.getThread(thread);
 
-		const emitter = new BufferedEventEmitter();
-		emitter.emit('start', thread);
-
-		return this.execute(thread, emitter);
+		yield {type: 'start', thread};
+		try {
+			yield* this.execute(thread);
+		} finally {
+			yield {type: 'end', thread};
+		}
 	}
 
-	async beforeExecute(thread, emitter) {
+	async beforeExecute(thread) {
 		if (this.options.memory_handler)
 			thread = await this.options.memory_handler.handle(thread);
 		return thread;
 	}
 
-	async execute(thread, emitter, counter = 0) {
-		const execution = new Promise(async (resolve, reject) => {
-			try {
-				if (counter === 0)
-					thread = await this.beforeExecute(thread, emitter);
-
-				const model = Symposium.getModel(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.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',
-								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;
-						}
-					}
-				}
+	async *execute(thread) {
+		thread = await this.beforeExecute(thread);
+
+		const model = Symposium.getModel(thread.state.model);
+
+		const completion_options = {};
+		if (this.response_schema) {
+			const schema = this.response_schema;
+			const converted = (schema.type === 'object' && model.structured_output)
+				? this.convertFunctionToResponseFormat(JSON.parse(JSON.stringify(schema)))
+				: null;
+
+			if (converted && converted.count <= 100) { // OpenAI does not support structured output if there are more than 100 parameters
+				completion_options.response_format = {
+					type: 'json_schema',
+					name: 'response',
+					schema: converted.obj,
+					strict: true,
+				};
+			} else {
+				completion_options.tools = [{
+					name: 'response',
+					parameters: schema,
+				}];
+				completion_options.force_tool = 'response';
+			}
+		}
 
+		const streamingState = this._streamingInputs.get(thread.unique);
+		const streaming = !!streamingState;
+
+		let counter = 0;
+		let output_yielded = false;
+		while (true) {
+			if (streaming) {
+				await this._drainPendingMessages(thread);
+				if (streamingState.controlFlags.cancelled)
+					return;
+			}
+
+			try {
+				// Inline drain of generateCompletion so we can observe `chunk`
+				// events and flip output_yielded for the hybrid retry strategy.
+				const it = this.generateCompletion(thread, completion_options);
+				let step = await it.next();
 				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');
-					}
+				while (!step.done) {
+					const ev = step.value;
+					if (ev?.type === 'chunk')
+						output_yielded = true;
+					yield ev;
+					step = await it.next();
 				}
+				completion = step.value;
 
-				try {
-					thread = await this.afterExecute(thread, completion, emitter);
+				thread = await this.afterExecute(thread, completion);
 
-					for (let message of completion) {
-						if (message.role === 'assistant' && message.content.some(c => c.type === 'reasoning')) {
-							const reasoning = message.content.find(c => c.type === 'reasoning').content;
-							if (reasoning)
-								emitter.emit('reasoning', reasoning);
-						}
+				for (let message of completion) {
+					if (message.role === 'assistant' && message.content.some(c => c.type === 'reasoning')) {
+						const reasoning = message.content.find(c => c.type === 'reasoning').content;
+						if (reasoning)
+							yield {type: 'reasoning', content: reasoning};
 					}
+				}
 
-					const response = await this.handleCompletion(thread, completion, emitter);
-
-					switch (this.type) {
-						case 'utility':
-							if (response.type !== 'response')
-								throw new Error('Utility agent did not return a response');
+				const verdict = yield* this.handleCompletion(thread, completion);
 
-							return resolve(response.value);
+				if (verdict?.type === 'response') {
+					yield {type: 'result', value: verdict.value};
+					return;
+				}
 
-						case 'chat':
-							if (response?.type === 'continue')
-								return this.execute(thread, emitter);
+				switch (this.type) {
+					case 'utility':
+						throw new Error('Utility agent did not return a response');
 
-							return resolve(null);
+					case 'chat':
+						if (verdict?.type === 'continue') {
+							counter = 0;
+							output_yielded = false;
+							continue;
+						}
+						if (streaming) {
+							const more = await this._awaitNextStreamingInput(thread);
+							if (!more)
+								return;
+							counter = 0;
+							output_yielded = false;
+							continue;
+						}
+						return;
 
-						default:
-							throw new Error('Bad agent type');
-					}
-				} catch (e) {
-					console.error(e);
-
-					if (counter < this.max_retries) {
-						await this.execute(thread, emitter, counter + 1)
-							.then(response => resolve(response))
-							.catch(err => reject(err));
-					} else {
-						throw e;
-					}
+					default:
+						throw new Error('Bad agent type');
 				}
 			} catch (e) {
-				reject(e);
+				if (counter < this.max_retries) {
+					counter++;
+					const reason = e?.message || String(e);
+					if (output_yielded)
+						yield {type: 'retry', attempt: counter, reason};
+					// Preserve the legacy 1-second backoff for transport-level 5xx.
+					if (e?.response?.status >= 500)
+						await new Promise(resolve => setTimeout(resolve, 1000));
+					output_yielded = false;
+					continue;
+				}
+				throw e;
 			}
-		}).then(value => {
-			emitter.emit('end', thread);
-			return value;
-		});
-
-		return this.type === 'chat' ? emitter : execution;
+		}
 	}
 
 	convertFunctionToResponseFormat(obj) {
@@ -348,41 +639,43 @@ ${context_string}
 		};
 	}
 
-	async afterExecute(thread, completion, emitter) {
+	async afterExecute(thread, completion) {
 		return thread;
 	}
 
-	async generateCompletion(thread, options = {}, retry_counter = 1) {
+	async *generateCompletion(thread, options = {}) {
+		const model = Symposium.getModel(thread.state.model);
+		const it = model.class.generate(model, thread, await this.getTools(), {
+			...options,
+			image_generation: this.enable_image_generation,
+		});
+
+		let messages;
 		try {
-			const model = Symposium.getModel(thread.state.model);
-			const messages = await model.class.generate(model, thread, await this.getFunctions(), {
-				...options,
-				image_generation: this.enable_image_generation,
-			});
-			return model.tools ? messages : messages.map(m => this.parseFunctions(m));
+			let step = await it.next();
+			while (!step.done) {
+				const delta = step.value;
+				if (delta && delta.type === 'text_delta')
+					yield {type: 'chunk', content: delta.content};
+				step = await it.next();
+			}
+			messages = step.value;
 		} catch (error) {
-			if (error.response) {
-				console.error(error.response.status);
-				console.error(error.response.data);
-
-				if (error.response.status >= 500 && retry_counter <= this.max_retries) {
-					await new Promise(resolve => {
-						setTimeout(resolve, 1000);
-					});
-
-					return this.generateCompletion(thread, options, retry_counter + 1);
-				}
-
-				throw new Error(error.response.status + ': ' + JSON.stringify(error.response.data));
-			} else if (error.message) {
-				throw new Error(error.message);
-			} else {
-				throw new Error('Errore interno');
+			// Normalize error shape; the outer execute loop owns retry policy.
+			if (error?.response) {
+				const normalized = new Error(error.response.status + ': ' + JSON.stringify(error.response.data));
+				normalized.response = error.response;
+				throw normalized;
 			}
+			if (error?.message)
+				throw new Error(error.message);
+			throw error;
 		}
+
+		return model.tools ? messages : messages.map(m => this.parseTools(m));
 	}
 
-	parseFunctions(message) {
+	parseTools(message) {
 		const newContent = [];
 		for (let m of message.content) {
 			if (m.type === 'text' && m.content.match(/```\nCALL [A-Za-z0-9_]+\n[\s\S]*```/)) {
@@ -394,7 +687,7 @@ ${context_string}
 
 					const match = text.match(/^CALL ([A-Za-z0-9_]+)\n([\s\S]*)$/);
 					if (match)
-						newContent.push({type: 'function', content: [{name: match[1], arguments: JSON.parse(match[2] || '{}')}]});
+						newContent.push({type: 'tool_call', content: [{name: match[1], arguments: JSON.parse(match[2] || '{}')}]});
 					else
 						newContent.push({type: 'text', content: text});
 				}
@@ -407,10 +700,10 @@ ${context_string}
 		return message;
 	}
 
-	async handleCompletion(thread, completion, emitter) {
+	async *handleCompletion(thread, completion) {
 		const model = Symposium.getModel(thread.state.model);
 
-		const functions = [];
+		const tool_calls = [];
 		for (let message of completion) {
 			thread.addDirectMessage(message);
 			await this.log('ai_message', message.content);
@@ -418,33 +711,31 @@ ${context_string}
 			for (let m of message.content) {
 				switch (m.type) {
 					case 'text':
-						if (this.type === 'utility') {
-							if (this.utility.type === 'text')
-								return {type: 'response', value: this.afterHandle(thread, completion, m.content)};
-							if (this.utility.type === 'json' && model.structured_output)
-								return {type: 'response', value: this.afterHandle(thread, completion, JSON.parse(m.content))};
-						}
+						if (this.response_schema && model.structured_output)
+							return {type: 'response', value: await this.afterHandle(thread, completion, JSON.parse(m.content))};
+						if (this.type === 'utility' && !this.response_schema)
+							return {type: 'response', value: await this.afterHandle(thread, completion, m.content)};
 
-						emitter.emit('output', m);
+						yield {type: 'output', content: m};
 						break;
 
 					case 'image':
-						emitter.emit('output', m);
+						yield {type: 'output', content: m};
 						break;
 
-					case 'function':
-						for (let f of m.content)
-							functions.push(f);
+					case 'tool_call':
+						for (let t of m.content)
+							tool_calls.push(t);
 						break;
 				}
 			}
 		}
 
-		if (functions.length) {
-			if (this.utility && ['function', 'json'].includes(this.utility.type))
-				return {type: 'response', value: this.afterHandle(thread, completion, functions[0].arguments)};
+		if (tool_calls.length) {
+			if (this.response_schema)
+				return {type: 'response', value: await this.afterHandle(thread, completion, tool_calls[0].arguments)};
 
-			return this.callFunctions(thread, emitter, completion, functions);
+			return yield* this.callTools(thread, completion, tool_calls);
 		} else {
 			await thread.storeState();
 			await this.afterHandle(thread, completion);
@@ -452,49 +743,54 @@ ${context_string}
 		}
 	}
 
-	async confirmFunctions({thread, functions, completion, emitter}, always = false) {
-		const response = await this.callFunctions(thread, emitter, completion, functions, true, always);
-		if (response?.type === 'continue')
-			return this.execute(thread, emitter);
-	}
-
-	async callFunctions(thread, emitter, completion, functions_to_call, authorize = false, authorize_always = false) {
-		const functions = await this.getFunctions(false);
+	async *callTools(thread, completion, tools_to_call) {
+		const tools = await this.getTools(false);
 
 		let is_authorized = true;
-		for (let f of functions_to_call) {
-			if (!functions.has(f.name))
-				throw new Error('Unrecognized function ' + f.name);
+		for (let t of tools_to_call) {
+			if (!tools.has(t.name))
+				throw new Error('Unrecognized tool ' + t.name);
 
-			if (authorize && authorize_always)
-				await functions.get(f.name).tool.authorizeAlways(thread, f.name, f.arguments);
-
-			if (!authorize && !(await functions.get(f.name).tool.authorize(thread, f.name, f.arguments))) {
+			if (!(await tools.get(t.name).toolkit.authorize(thread, t.name, t.arguments))) {
 				is_authorized = false;
 				break;
 			}
 		}
 
 		if (!is_authorized) {
-			emitter.emit('tools_auth', {thread, functions: functions_to_call, completion, emitter});
-			return {type: 'void'};
+			const id = uuid();
+			yield {type: 'tools_auth', id, tools: tools_to_call};
+
+			const decision = await this._awaitAuthDecision(thread, id);
+
+			if (decision === 'reject')
+				return {type: 'void'};
+
+			if (decision === 'approve_always') {
+				for (let t of tools_to_call)
+					await tools.get(t.name).toolkit.authorizeAlways(thread, t.name, t.arguments);
+			} else if (decision !== 'approve') {
+				throw new Error('Bad authorization decision: ' + decision);
+			}
 		}
 
-		const responses = await Promise.all(functions_to_call.map(async f => this.callFunction(thread, functions, f, emitter)));
+		const responses = [];
+		for (let t of tools_to_call)
+			responses.push(yield* this.callTool(thread, tools, t));
 
 		for (let response of responses) {
 			thread.addMessage('tool', [
 				{
-					type: 'function_response',
+					type: 'tool_result',
 					content: {
-						name: response.function.name,
-						id: response.function.id || undefined,
+						name: response.tool_call.name,
+						id: response.tool_call.id || undefined,
 						response: response.response,
 					},
 				},
-			], response.function.name);
+			], response.tool_call.name);
 
-			await this.log('function_response', response);
+			await this.log('tool_result', response);
 		}
 
 		thread.flushPlannedMessages();
@@ -503,53 +799,51 @@ ${context_string}
 		return {type: 'continue'};
 	}
 
-	async getFunctions(parsed = true) {
-		if (this.functions === null) {
-			this.functions = new Map();
-			for (let tool of this.tools.values()) {
-				let functions = await tool.getFunctions();
-				for (let func of functions) {
-					if (this.functions.has(func.name))
-						throw new Error('Duplicate function ' + func.name + ' in agent');
-
-					this.functions.set(func.name, {
-						tool,
-						function: func,
+	async getTools(parsed = true) {
+		if (this.tools === null) {
+			this.tools = new Map();
+			for (let toolkit of this.toolkits.values()) {
+				let toolDefs = await toolkit.getTools();
+				for (let toolDef of toolDefs) {
+					if (this.tools.has(toolDef.name))
+						throw new Error('Duplicate tool ' + toolDef.name + ' in agent');
+
+					this.tools.set(toolDef.name, {
+						toolkit,
+						definition: toolDef,
 					});
 				}
 			}
 		}
 
 		if (parsed)
-			return Array.from(this.functions.values()).map(f => f.function)
+			return Array.from(this.tools.values()).map(e => e.definition)
 		else
-			return this.functions;
+			return this.tools;
 	}
 
-	async callFunction(thread, functions, function_call, emitter = null) {
-		const function_definition = functions.get(function_call.name);
+	async *callTool(thread, tools, tool_call) {
+		const entry = tools.get(tool_call.name);
 
-		await this.log('function_call', function_call);
-		emitter.emit('tool', function_call);
+		await this.log('tool_call', tool_call);
+		yield {type: 'tool', id: tool_call.id, name: tool_call.name, arguments: tool_call.arguments};
 
 		try {
-			const response = await function_definition.tool.callFunction(thread, function_call.name, function_call.arguments);
-			if (emitter)
-				emitter.emit('tool_response', {name: function_definition.tool.name, success: true, response});
+			const response = await entry.toolkit.callTool(thread, tool_call.name, tool_call.arguments);
+			yield {type: 'tool_response', name: entry.toolkit.name, success: true, response};
 
 			return {
 				type: 'response',
 				response,
-				function: function_call,
+				tool_call,
 			};
 		} catch (error) {
-			if (emitter)
-				emitter.emit('tool_response', {name: function_definition.tool.name, success: false, error: error.message || error});
+			yield {type: 'tool_response', name: entry.toolkit.name, success: false, error: error.message || error};
 
 			return {
 				type: 'response',
 				response: {error},
-				function: function_call,
+				tool_call,
 			};
 		}
 	}
@@ -558,10 +852,6 @@ ${context_string}
 		return value;
 	}
 
-	getEmitter() {
-		return new BufferedEventEmitter();
-	}
-
 	async setModel(thread, label) {
 		const model_to_switch = Symposium.getModel(label);
 		if (model_to_switch && model_to_switch.type === 'llm')
@@ -602,7 +892,7 @@ ${context_string}
 		if (conversation.length && options.include_thread)
 			instructions += '\n\n# Ecco la tua conversazione fino ad ora: #\n' + conversation.join('\n');
 
-		const tools = (await this.getFunctions()).map(t => ({
+		const tools = (await this.getTools()).map(t => ({
 			type: 'function',
 			...t,
 		}));