symposium 2.1.9 → 2.2.0

package/Agent.js

@@ -22,6 +22,7 @@ export default class Agent {
 	type = 'chat'; // chat, utility
 	utility = null;
 	initialized = false;
+	enable_image_generation = false;
 
 	constructor(options) {
 		this.options = {
@@ -218,11 +219,9 @@ export default class Agent {
 						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,
-								},
+								name: this.utility.function.name,
+								schema: response_format.obj,
+								strict: true,
 							};
 						} else {
 							completion_options.functions = [
@@ -341,7 +340,10 @@ export default class Agent {
 	async generateCompletion(thread, options = {}, retry_counter = 1) {
 		try {
 			const model = Symposium.getModel(thread.state.model);
-			const messages = await model.class.generate(model, thread, await this.getFunctions(), options);
+			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));
 		} catch (error) {
 			if (error.response) {

package/Models/DeepSeekModel.js

@@ -1,7 +1,7 @@
-import OpenAIModel from "./OpenAIModel.js";
+import LegacyOpenAIModel from "./LegacyOpenAIModel.js";
 import OpenAI from "openai";
 
-export default class DeepSeekModel extends OpenAIModel {
+export default class DeepSeekModel extends LegacyOpenAIModel {
 	async getModels() {
 		return new Map([
 			['deepseek-chat', {

package/Models/GrokModel.js

@@ -1,7 +1,7 @@
-import OpenAIModel from "./OpenAIModel.js";
+import LegacyOpenAIModel from "./LegacyOpenAIModel.js";
 import OpenAI from "openai";
 
-export default class GrokModel extends OpenAIModel {
+export default class GrokModel extends LegacyOpenAIModel {
 	async getModels() {
 		return new Map([
 			['grok-4', {

package/Models/LegacyOpenAIModel.js

@@ -0,0 +1,223 @@
+import Model from "../Model.js";
+import OpenAI from "openai";
+import Message from "../Message.js";
+import {encoding_for_model} from "tiktoken";
+
+export default class LegacyOpenAIModel extends Model {
+	openai;
+
+	async getModels() {
+		return new Map([]);
+	}
+
+	getOpenAi() {
+		if (!this.openai)
+			this.openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});
+
+		return this.openai;
+	}
+
+	async generate(model, thread, functions = [], options = {}) {
+		const parsed = this.parseOptions(options, functions);
+		options = parsed.options;
+		functions = parsed.functions;
+
+		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);
+			let system_messages = [], other_messages = [], first_found = false;
+			for (let message of messages) {
+				if (!first_found && message.role !== 'system')
+					first_found = true;
+
+				if (!first_found)
+					system_messages.push(message);
+				else
+					other_messages.push(message);
+			}
+
+			system_messages.push(new Message('system', functions_prompt));
+
+			messages = [...system_messages, ...other_messages];
+			functions = [];
+		}
+
+		const convertedMessages = [];
+		for (let m of messages)
+			convertedMessages.push(...this.convertMessage(m, model));
+
+		const completion_payload = {
+			model: model.name,
+			messages: convertedMessages,
+			tools: functions.map(f => ({
+				type: 'function',
+				function: f,
+			})),
+		};
+
+		if (options.force_function) {
+			completion_payload.tool_choice = {
+				type: 'function',
+				function: {name: options.force_function},
+			};
+		}
+
+		if (options.response_format)
+			completion_payload.response_format = options.response_format;
+
+		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 message_content = [];
+		if (completion.content)
+			message_content.push({type: 'text', content: completion.content});
+
+		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) : {},
+					};
+				}),
+			});
+		}
+
+		return [
+			new Message('assistant', message_content),
+		];
+	}
+
+	async countTokens(thread) {
+		try {
+			const model = (await this.getModels()).get(thread.state.model);
+			const encoder = encoding_for_model(model.tiktoken || model.name);
+
+			const texts = [];
+			for (let message of thread.messages)
+				texts.push(message.content.map(m => typeof m.content === 'string' ? m.content : JSON.stringify(m.content)).join(''));
+			return encoder.encode(texts.join('')).length;
+		} catch (e) {
+			throw new Error('Error while counting tokens');
+		}
+	}
+
+	convertMessage(message, model) {
+		const messages = [],
+			role = message.role === 'system' ? this.system_role_name : message.role;
+
+		for (let c of message.content) {
+			switch (c.type) {
+				case 'text':
+					messages.push({
+						role,
+						content: c.content,
+						name: message.name,
+					});
+					break;
+
+				case 'image':
+					messages.push({
+						role,
+						content: [
+							{
+								type: 'image_url',
+								image_url: {
+									url: c.content.type === 'base64' ? 'data:' + c.content.mime + ';base64,' + c.content.data : c.content.data,
+									detail: c.content.detail || 'auto',
+								},
+							},
+						],
+						name: message.name,
+					});
+					break;
+
+				case 'audio':
+					if (model.audio) {
+						if (c.content.type !== 'base64')
+							throw new Error('Audio content must be base64 encoded for this model');
+						if (!['audio/mpeg', 'audio/wav'].includes(c.content.mime))
+							throw new Error('Audio content must have a valid MIME type');
+
+						messages.push({
+							role,
+							content: [
+								{
+									type: 'input_audio',
+									input_audio: {
+										data: c.content.data,
+										format: c.content.mime === 'audio/mpeg' ? 'mp3' : 'wav',
+									},
+								},
+							],
+							name: message.name,
+						});
+					} else if (c.content.transcription) {
+						messages.push({
+							role,
+							content: '[transcribed] ' + c.content.transcription,
+							name: message.name,
+						});
+					} else {
+						throw new Error('Audio content is not supported by this model');
+					}
+					break;
+
+				case 'function':
+					if (model.tools) {
+						messages.push({
+							role,
+							name: message.name,
+							tool_calls: c.content.map(tool_call => ({
+								id: tool_call.id,
+								type: 'function',
+								function: {
+									name: tool_call.name,
+									arguments: tool_call.arguments ? JSON.stringify(tool_call.arguments) : '{}',
+								},
+							})),
+						});
+					} else {
+						messages.push({
+							role,
+							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
+							name: message.name,
+						});
+					}
+					break;
+
+				case 'function_response':
+					if (model.tools) {
+						messages.push({
+							role,
+							tool_call_id: c.content.id,
+							content: JSON.stringify(c.content.response),
+							name: message.name,
+						});
+					} else {
+						messages.push({
+							role: 'user',
+							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
+							name: message.name,
+						});
+					}
+					break;
+
+				default:
+					throw new Error('Message type unsupported by this model');
+			}
+		}
+
+		return messages;
+	}
+}

package/Models/OpenAIModel.js

@@ -22,6 +22,7 @@ export default class OpenAIModel extends Model {
 				tools: true,
 				structured_output: true,
 				audio: true,
+				image_generation: true,
 			}],
 			['gpt-5-mini', {
 				name: 'gpt-5-mini',
@@ -71,49 +72,69 @@ export default class OpenAIModel extends Model {
 		for (let m of messages)
 			convertedMessages.push(...this.convertMessage(m, model));
 
+		const tools = functions.map(f => ({
+			type: 'function',
+			...f,
+		}));
+
+		if (model.tools && model.image_generation && options.image_generation)
+			tools.push({type: 'image_generation'});
+
 		const completion_payload = {
 			model: model.name,
-			messages: convertedMessages,
-			tools: functions.map(f => ({
-				type: 'function',
-				function: f,
-			})),
+			input: convertedMessages,
+			store: false,
+			include: ['reasoning.encrypted_content'],
+			tools,
+			reasoning: {
+				summary: 'auto',
+			},
 		};
 
 		if (options.force_function) {
 			completion_payload.tool_choice = {
 				type: 'function',
-				function: {name: options.force_function},
+				name: options.force_function,
 			};
 		}
 
 		if (options.response_format)
-			completion_payload.response_format = options.response_format;
+			completion_payload.text = {format: options.response_format};
 
 		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 completion = await this.getOpenAi().responses.create(completion_payload);
 
 		const message_content = [];
-		if (completion.content)
-			message_content.push({type: 'text', content: completion.content});
+		for (let output of completion.output) {
+			switch (output.type) {
+				case 'message':
+					let text = output.content.map(c => c.text).join('\n');
+					message_content.push({type: 'text', content: text});
+					break;
 
-		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) : {},
-					};
-				}),
-			});
+				case 'function_call':
+					message_content.push({
+						type: 'function',
+						content: [
+							{
+								id: output.call_id,
+								name: output.name,
+								arguments: output.arguments ? JSON.parse(output.arguments) : {},
+							},
+						],
+					});
+					break;
+
+				case 'reasoning':
+					message_content.push({
+						type: 'reasoning',
+						content: output.summary?.length ? output.summary.map(s => s.text).join('\n') : null,
+						original: output,
+					});
+					break;
+			}
 		}
 
 		return [
@@ -145,7 +166,6 @@ export default class OpenAIModel extends Model {
 					messages.push({
 						role,
 						content: c.content,
-						name: message.name,
 					});
 					break;
 
@@ -161,7 +181,6 @@ export default class OpenAIModel extends Model {
 								},
 							},
 						],
-						name: message.name,
 					});
 					break;
 
@@ -183,13 +202,11 @@ export default class OpenAIModel extends Model {
 									},
 								},
 							],
-							name: message.name,
 						});
 					} else if (c.content.transcription) {
 						messages.push({
 							role,
 							content: '[transcribed] ' + c.content.transcription,
-							name: message.name,
 						});
 					} else {
 						throw new Error('Audio content is not supported by this model');
@@ -199,22 +216,15 @@ export default class OpenAIModel extends Model {
 				case 'function':
 					if (model.tools) {
 						messages.push({
-							role,
-							name: message.name,
-							tool_calls: c.content.map(tool_call => ({
-								id: tool_call.id,
-								type: 'function',
-								function: {
-									name: tool_call.name,
-									arguments: tool_call.arguments ? JSON.stringify(tool_call.arguments) : '{}',
-								},
-							})),
+							type: 'function_call',
+							call_id: c.content[0].id,
+							name: c.content[0].name,
+							arguments: c.content[0].arguments ? JSON.stringify(c.content[0].arguments) : '{}',
 						});
 					} else {
 						messages.push({
 							role,
 							content: c.content.map(f => '```CALL \n' + f.name + '\n' + JSON.stringify(f.arguments || {}) + '\n```').join("\n\n"),
-							name: message.name,
 						});
 					}
 					break;
@@ -222,20 +232,22 @@ export default class OpenAIModel extends Model {
 				case 'function_response':
 					if (model.tools) {
 						messages.push({
-							role,
-							tool_call_id: c.content.id,
-							content: JSON.stringify(c.content.response),
-							name: message.name,
+							type: 'function_call_output',
+							call_id: c.content.id,
+							output: JSON.stringify(c.content.response),
 						});
 					} else {
 						messages.push({
 							role: 'user',
 							content: 'FUNCTION RESPONSE:\n' + JSON.stringify(c.content.response),
-							name: message.name,
 						});
 					}
 					break;
 
+				case 'reasoning':
+					messages.push(c.original);
+					break;
+
 				default:
 					throw new Error('Message type unsupported by this model');
 			}

package/package.json

@@ -1,13 +1,13 @@
 {
   "type": "module",
   "name": "symposium",
-  "version": "2.1.9",
+  "version": "2.2.0",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.67.0",
+    "@anthropic-ai/sdk": "^0.68.0",
     "groq-sdk": "^0.34.0",
     "ollama": "^0.6.0",
     "openai": "^6.0.0",