symposium 2.4.2 → 3.0.0

package/Models/GroqModel.js

@@ -27,16 +27,16 @@ export default class GroqModel extends Model {
 		return this.groq;
 	}
 
-	async generate(model, thread, functions = [], options = {}) {
-		const parsed = this.parseOptions(options, functions);
+	async *generate(model, thread, tools = [], options = {}) {
+		const parsed = this.parseOptions(options, tools);
 		options = parsed.options;
-		functions = parsed.functions;
+		tools = parsed.tools;
 
 		let messages = thread.messages;
 
-		if (functions.length && !model.tools) {
-			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
-			const functions_prompt = this.promptFromFunctions(options, functions);
+		if (tools.length && !model.tools) {
+			// Se il modello non supporta nativamente gli strumenti, inserisco il prompt ad hoc come ultimo messaggio di sistema
+			const tools_prompt = this.promptFromTools(options, tools);
 			let system_messages = [], other_messages = [], first_found = false;
 			for (let message of messages) {
 				if (!first_found && message.role !== 'system')
@@ -48,10 +48,10 @@ export default class GroqModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push(new Message('system', functions_prompt));
+			system_messages.push(new Message('system', tools_prompt));
 
 			messages = [...system_messages, ...other_messages];
-			functions = [];
+			tools = [];
 		}
 
 		const convertedMessages = [];
@@ -61,45 +61,71 @@ export default class GroqModel extends Model {
 		const completion_payload = {
 			model: model.name,
 			messages: convertedMessages,
-			tools: functions.map(f => ({
+			tools: tools.map(t => ({
 				type: 'function',
-				function: f,
+				function: t,
 			})),
 		};
 
-		if (options.force_function) {
+		if (options.force_tool) {
 			completion_payload.tool_choice = {
 				type: 'function',
-				function: {name: options.force_function},
+				function: {name: options.force_tool},
 			};
 		}
 
 		if (!completion_payload.tools.length)
 			delete completion_payload.tools;
 
-		const chatCompletion = await this.getGroq().chat.completions.create(completion_payload);
-		const completion = chatCompletion.choices[0].message;
+		const stream = await this.getGroq().chat.completions.create({...completion_payload, stream: true});
 
-		const message_content = [];
-		if (completion.content)
-			message_content.push({type: 'text', content: completion.content});
+		let fullText = '';
+		const toolBuffer = new Map();
 
-		if (completion.tool_calls?.length) {
-			message_content.push({
-				type: 'function',
-				content: completion.tool_calls.map(tool_call => {
-					if (tool_call.type !== 'function')
-						throw new Error('Unsupported tool type ' + tool_call.type);
-
-					return {
-						id: tool_call.id,
-						name: tool_call.function.name,
-						arguments: tool_call.function.arguments ? JSON.parse(tool_call.function.arguments) : {},
-					};
-				}),
-			});
+		for await (const chunk of stream) {
+			const delta = chunk.choices?.[0]?.delta;
+			if (!delta)
+				continue;
+
+			if (delta.content) {
+				fullText += delta.content;
+				yield {type: 'text_delta', content: delta.content};
+			}
+
+			if (delta.tool_calls) {
+				for (const tc of delta.tool_calls) {
+					const idx = tc.index;
+					if (!toolBuffer.has(idx))
+						toolBuffer.set(idx, {id: '', name: '', argumentsRaw: ''});
+					const buf = toolBuffer.get(idx);
+					if (tc.id)
+						buf.id = tc.id;
+					if (tc.function?.name)
+						buf.name = tc.function.name;
+					if (tc.function?.arguments)
+						buf.argumentsRaw += tc.function.arguments;
+				}
+			}
 		}
 
+		const toolCalls = [];
+		for (const [, buf] of [...toolBuffer.entries()].sort((a, b) => a[0] - b[0])) {
+			const tc = {
+				id: buf.id,
+				name: buf.name,
+				arguments: buf.argumentsRaw ? JSON.parse(buf.argumentsRaw) : {},
+			};
+			toolCalls.push(tc);
+			yield {type: 'tool_call', content: tc};
+		}
+
+		const message_content = [];
+		if (fullText)
+			message_content.push({type: 'text', content: fullText});
+
+		if (toolCalls.length)
+			message_content.push({type: 'tool_call', content: toolCalls});
+
 		return [
 			new Message('assistant', message_content),
 		];
@@ -132,7 +158,7 @@ export default class GroqModel extends Model {
 					});
 					break;
 
-				case 'function':
+				case 'tool_call':
 					if (model.tools) {
 						messages.push({
 							role: message.role,
@@ -149,13 +175,13 @@ export default class GroqModel extends Model {
 					} else {
 						messages.push({
 							role: message.role,
-							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							content: c.content.map(t => '```CALL \n' + t.name + '\n' + JSON.stringify(t.arguments || {}) + '\n```').join("\n\n"),
 							name: message.name,
 						});
 					}
 					break;
 
-				case 'function_response':
+				case 'tool_result':
 					if (model.tools) {
 						messages.push({
 							role: message.role,
@@ -166,7 +192,7 @@ export default class GroqModel extends Model {
 					} else {
 						messages.push({
 							role: 'user',
-							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							content: 'TOOL RESPONSE:\n' + JSON.stringify(c.content.response),
 							name: message.name,
 						});
 					}

package/Models/LegacyOpenAIModel.js

@@ -17,16 +17,16 @@ export default class LegacyOpenAIModel extends Model {
 		return this.openai;
 	}
 
-	async generate(model, thread, functions = [], options = {}) {
-		const parsed = this.parseOptions(options, functions);
+	async *generate(model, thread, tools = [], options = {}) {
+		const parsed = this.parseOptions(options, tools);
 		options = parsed.options;
-		functions = parsed.functions;
+		tools = parsed.tools;
 
 		let messages = thread.messages;
 
-		if (functions.length && !model.tools) {
-			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
-			const functions_prompt = this.promptFromFunctions(options, functions);
+		if (tools.length && !model.tools) {
+			// Se il modello non supporta nativamente gli strumenti, inserisco il prompt ad hoc come ultimo messaggio di sistema
+			const tools_prompt = this.promptFromTools(options, tools);
 			let system_messages = [], other_messages = [], first_found = false;
 			for (let message of messages) {
 				if (!first_found && message.role !== 'system')
@@ -38,10 +38,10 @@ export default class LegacyOpenAIModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push(new Message('system', functions_prompt));
+			system_messages.push(new Message('system', tools_prompt));
 
 			messages = [...system_messages, ...other_messages];
-			functions = [];
+			tools = [];
 		}
 
 		const convertedMessages = [];
@@ -51,16 +51,16 @@ export default class LegacyOpenAIModel extends Model {
 		const completion_payload = {
 			model: model.name,
 			messages: convertedMessages,
-			tools: functions.map(f => ({
+			tools: tools.map(t => ({
 				type: 'function',
-				function: f,
+				function: t,
 			})),
 		};
 
-		if (options.force_function) {
+		if (options.force_tool) {
 			completion_payload.tool_choice = {
 				type: 'function',
-				function: {name: options.force_function},
+				function: {name: options.force_tool},
 			};
 		}
 
@@ -70,29 +70,55 @@ export default class LegacyOpenAIModel extends Model {
 		if (!completion_payload.tools.length)
 			delete completion_payload.tools;
 
-		const chatCompletion = await this.getOpenAi().chat.completions.create(completion_payload);
-		const completion = chatCompletion.choices[0].message;
+		const stream = await this.getOpenAi().chat.completions.create({...completion_payload, stream: true});
 
-		const message_content = [];
-		if (completion.content)
-			message_content.push({type: 'text', content: completion.content});
+		let fullText = '';
+		const toolBuffer = new Map();
 
-		if (completion.tool_calls?.length) {
-			message_content.push({
-				type: 'function',
-				content: completion.tool_calls.map(tool_call => {
-					if (tool_call.type !== 'function')
-						throw new Error('Unsupported tool type ' + tool_call.type);
-
-					return {
-						id: tool_call.id,
-						name: tool_call.function.name,
-						arguments: tool_call.function.arguments ? JSON.parse(tool_call.function.arguments) : {},
-					};
-				}),
-			});
+		for await (const chunk of stream) {
+			const delta = chunk.choices?.[0]?.delta;
+			if (!delta)
+				continue;
+
+			if (delta.content) {
+				fullText += delta.content;
+				yield {type: 'text_delta', content: delta.content};
+			}
+
+			if (delta.tool_calls) {
+				for (const tc of delta.tool_calls) {
+					const idx = tc.index;
+					if (!toolBuffer.has(idx))
+						toolBuffer.set(idx, {id: '', name: '', argumentsRaw: ''});
+					const buf = toolBuffer.get(idx);
+					if (tc.id)
+						buf.id = tc.id;
+					if (tc.function?.name)
+						buf.name = tc.function.name;
+					if (tc.function?.arguments)
+						buf.argumentsRaw += tc.function.arguments;
+				}
+			}
 		}
 
+		const toolCalls = [];
+		for (const [, buf] of [...toolBuffer.entries()].sort((a, b) => a[0] - b[0])) {
+			const tc = {
+				id: buf.id,
+				name: buf.name,
+				arguments: buf.argumentsRaw ? JSON.parse(buf.argumentsRaw) : {},
+			};
+			toolCalls.push(tc);
+			yield {type: 'tool_call', content: tc};
+		}
+
+		const message_content = [];
+		if (fullText)
+			message_content.push({type: 'text', content: fullText});
+
+		if (toolCalls.length)
+			message_content.push({type: 'tool_call', content: toolCalls});
+
 		return [
 			new Message('assistant', message_content),
 		];
@@ -173,7 +199,7 @@ export default class LegacyOpenAIModel extends Model {
 					}
 					break;
 
-				case 'function':
+				case 'tool_call':
 					if (model.tools) {
 						messages.push({
 							role,
@@ -190,13 +216,13 @@ export default class LegacyOpenAIModel extends Model {
 					} else {
 						messages.push({
 							role,
-							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							content: c.content.map(t => '```CALL \n' + t.name + '\n' + JSON.stringify(t.arguments || {}) + '\n```').join("\n\n"),
 							name: message.name,
 						});
 					}
 					break;
 
-				case 'function_response':
+				case 'tool_result':
 					if (model.tools) {
 						messages.push({
 							role,
@@ -207,7 +233,7 @@ export default class LegacyOpenAIModel extends Model {
 					} else {
 						messages.push({
 							role: 'user',
-							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							content: 'TOOL RESPONSE:\n' + JSON.stringify(c.content.response),
 							name: message.name,
 						});
 					}

package/Models/OllamaModel.js

@@ -3,9 +3,13 @@ import Model from "../Model.js";
 import Message from "../Message.js";
 
 export default class OllamaModel extends Model {
+	getOllama() {
+		return ollama;
+	}
+
 	async getModels() {
 		try {
-			const {models} = await ollama.list();
+			const {models} = await this.getOllama().list();
 
 			const map = new Map();
 
@@ -25,16 +29,16 @@ export default class OllamaModel extends Model {
 		}
 	}
 
-	async generate(model, thread, functions = [], options = {}) {
-		const parsed = this.parseOptions(options, functions);
+	async *generate(model, thread, tools = [], options = {}) {
+		const parsed = this.parseOptions(options, tools);
 		options = parsed.options;
-		functions = parsed.functions;
+		tools = parsed.tools;
 
 		let messages = thread.messages;
 
-		if (functions.length && !model.tools) {
-			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
-			const functions_prompt = this.promptFromFunctions(options, functions);
+		if (tools.length && !model.tools) {
+			// Se il modello non supporta nativamente gli strumenti, inserisco il prompt ad hoc come ultimo messaggio di sistema
+			const tools_prompt = this.promptFromTools(options, tools);
 			let system_messages = [], other_messages = [], first_found = false;
 			for (let message of messages) {
 				if (!first_found && message.role !== 'system')
@@ -46,10 +50,10 @@ export default class OllamaModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push(new Message('system', functions_prompt));
+			system_messages.push(new Message('system', tools_prompt));
 
 			messages = [...system_messages, ...other_messages];
-			functions = [];
+			tools = [];
 		}
 
 		const convertedMessages = [];
@@ -59,16 +63,17 @@ export default class OllamaModel extends Model {
 		const completion_payload = {
 			model: model.name,
 			messages: convertedMessages,
-			tools: functions.map(f => ({
+			tools: tools.map(t => ({
 				type: 'function',
-				function: f,
+				function: t,
 			})),
+			stream: true,
 		};
 
-		if (options.force_function) {
+		if (options.force_tool) {
 			completion_payload.tool_choice = {
 				type: 'function',
-				function: {name: options.force_function},
+				function: {name: options.force_tool},
 			};
 		}
 
@@ -81,31 +86,52 @@ export default class OllamaModel extends Model {
 		if (!completion_payload.tools.length)
 			delete completion_payload.tools;
 
-		const chatCompletion = await ollama.chat(completion_payload);
-		const completion = chatCompletion.message;
+		const stream = await this.getOllama().chat(completion_payload);
 
-		const message_content = [];
-		if (completion.thinking)
-			message_content.push({type: 'reasoning', content: completion.thinking});
+		let fullText = '';
+		let fullThinking = '';
+		const toolCalls = [];
 
-		if (completion.content)
-			message_content.push({type: 'text', content: completion.content});
+		for await (const chunk of stream) {
+			const m = chunk.message;
+			if (!m)
+				continue;
 
-		if (completion.tool_calls?.length) {
-			message_content.push({
-				type: 'function',
-				content: completion.tool_calls.map(tool_call => {
+			if (m.thinking) {
+				fullThinking += m.thinking;
+				yield {type: 'reasoning_delta', content: m.thinking};
+			}
+
+			if (m.content) {
+				fullText += m.content;
+				yield {type: 'text_delta', content: m.content};
+			}
+
+			if (m.tool_calls?.length) {
+				for (const tool_call of m.tool_calls) {
 					if (!tool_call.function)
 						throw new Error('Unsupported tool type');
 
-					return {
+					const tc = {
 						name: tool_call.function.name,
 						arguments: tool_call.function.arguments || {},
 					};
-				}),
-			});
+					toolCalls.push(tc);
+					yield {type: 'tool_call', content: tc};
+				}
+			}
 		}
 
+		const message_content = [];
+		if (fullThinking)
+			message_content.push({type: 'reasoning', content: fullThinking});
+
+		if (fullText)
+			message_content.push({type: 'text', content: fullText});
+
+		if (toolCalls.length)
+			message_content.push({type: 'tool_call', content: toolCalls});
+
 		return [
 			new Message('assistant', message_content),
 		];
@@ -130,7 +156,7 @@ export default class OllamaModel extends Model {
 					});
 					break;
 
-				case 'function':
+				case 'tool_call':
 					if (model.tools) {
 						messages.push({
 							role,
@@ -148,12 +174,12 @@ export default class OllamaModel extends Model {
 						messages.push({
 							role,
 							thinking: reasoning || undefined,
-							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							content: c.content.map(t => '```CALL \n' + t.name + '\n' + JSON.stringify(t.arguments || {}) + '\n```').join("\n\n"),
 						});
 					}
 					break;
 
-				case 'function_response':
+				case 'tool_result':
 					if (model.tools) {
 						messages.push({
 							role: 'tool',
@@ -163,7 +189,7 @@ export default class OllamaModel extends Model {
 					} else {
 						messages.push({
 							role: 'user',
-							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							content: 'TOOL RESPONSE:\n' + JSON.stringify(c.content.response),
 						});
 					}
 					break;

package/Models/OpenAIModel.js

@@ -58,6 +58,15 @@ export default class OpenAIModel extends Model {
 				audio: false,
 				image_generation: false,
 			}],
+			['gpt-5.4', {
+				name: 'gpt-5.4',
+				tiktoken: 'gpt-4',
+				tokens: 1000000,
+				tools: true,
+				structured_output: true,
+				audio: false,
+				image_generation: false,
+			}],
 		]);
 	}
 
@@ -68,16 +77,16 @@ export default class OpenAIModel extends Model {
 		return this.openai;
 	}
 
-	async generate(model, thread, functions = [], options = {}) {
-		const parsed = this.parseOptions(options, functions);
+	async *generate(model, thread, tools = [], options = {}) {
+		const parsed = this.parseOptions(options, tools);
 		options = parsed.options;
-		functions = parsed.functions;
+		tools = parsed.tools;
 
 		let messages = thread.messages;
 
-		if (functions.length && !model.tools) {
-			// Se il modello non supporta nativamente le funzioni, inserisco il prompt ad hoc come ultimo messaggio di sistema
-			const functions_prompt = this.promptFromFunctions(options, functions);
+		if (tools.length && !model.tools) {
+			// Se il modello non supporta nativamente gli strumenti, inserisco il prompt ad hoc come ultimo messaggio di sistema
+			const tools_prompt = this.promptFromTools(options, tools);
 			let system_messages = [], other_messages = [], first_found = false;
 			for (let message of messages) {
 				if (!first_found && message.role !== 'system')
@@ -89,39 +98,39 @@ export default class OpenAIModel extends Model {
 					other_messages.push(message);
 			}
 
-			system_messages.push(new Message('system', functions_prompt));
+			system_messages.push(new Message('system', tools_prompt));
 
 			messages = [...system_messages, ...other_messages];
-			functions = [];
+			tools = [];
 		}
 
 		const convertedMessages = [];
 		for (let m of messages)
 			convertedMessages.push(...(await this.convertMessage(m, model)));
 
-		const tools = functions.map(f => ({
+		const apiTools = tools.map(t => ({
 			type: 'function',
-			...f,
+			...t,
 		}));
 
 		if (model.tools && model.image_generation && options.image_generation)
-			tools.push({type: 'image_generation'});
+			apiTools.push({type: 'image_generation'});
 
 		const completion_payload = {
 			model: model.name,
 			input: convertedMessages,
 			store: false,
 			include: ['reasoning.encrypted_content'],
-			tools,
+			tools: apiTools,
 			reasoning: {
 				summary: 'auto',
 			},
 		};
 
-		if (options.force_function) {
+		if (options.force_tool) {
 			completion_payload.tool_choice = {
 				type: 'function',
-				name: options.force_function,
+				name: options.force_tool,
 			};
 		}
 
@@ -131,7 +140,52 @@ export default class OpenAIModel extends Model {
 		if (!completion_payload.tools.length)
 			delete completion_payload.tools;
 
-		const completion = await this.getOpenAi().responses.create(completion_payload);
+		const stream = this.getOpenAi().responses.stream(completion_payload);
+
+		for await (const event of stream) {
+			switch (event.type) {
+				case 'response.output_text.delta':
+					if (event.delta)
+						yield {type: 'text_delta', content: event.delta};
+					break;
+
+				case 'response.reasoning_summary_text.delta':
+					if (event.delta)
+						yield {type: 'reasoning_delta', content: event.delta};
+					break;
+
+				case 'response.output_item.done':
+					if (event.item?.type === 'function_call') {
+						yield {
+							type: 'tool_call',
+							content: {
+								id: event.item.call_id,
+								name: event.item.name,
+								arguments: event.item.arguments ? JSON.parse(event.item.arguments) : {},
+							},
+						};
+					} else if (event.item?.type === 'image_generation_call') {
+						const mime = event.item.output_format === 'png' ? 'image/png' : 'image/jpeg';
+						yield {
+							type: 'image',
+							content: {
+								type: 'base64',
+								mime,
+								data: event.item.result,
+							},
+							meta: {
+								id: event.item.id,
+								status: event.item.status,
+								prompt: event.item.revised_prompt,
+								size: event.item.size,
+							},
+						};
+					}
+					break;
+			}
+		}
+
+		const completion = await stream.finalResponse();
 
 		const message_content = [];
 		for (let output of completion.output) {
@@ -161,7 +215,7 @@ export default class OpenAIModel extends Model {
 
 				case 'function_call':
 					message_content.push({
-						type: 'function',
+						type: 'tool_call',
 						content: [
 							{
 								id: output.call_id,
@@ -275,7 +329,7 @@ export default class OpenAIModel extends Model {
 					}
 					break;
 
-				case 'function':
+				case 'tool_call':
 					if (model.tools) {
 						messages.push({
 							type: 'function_call',
@@ -286,12 +340,12 @@ export default class OpenAIModel extends Model {
 					} else {
 						messages.push({
 							role,
-							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							content: c.content.map(t => '```CALL \n' + t.name + '\n' + JSON.stringify(t.arguments || {}) + '\n```').join("\n\n"),
 						});
 					}
 					break;
 
-				case 'function_response':
+				case 'tool_result':
 					if (model.tools) {
 						messages.push({
 							type: 'function_call_output',
@@ -301,7 +355,7 @@ export default class OpenAIModel extends Model {
 					} else {
 						messages.push({
 							role: 'user',
-							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							content: 'TOOL RESPONSE:\n' + JSON.stringify(c.content.response),
 						});
 					}
 					break;