symposium 0.14.20 → 0.15.0

package/Agent.js

@@ -1,6 +1,9 @@
+import {v7 as uuid} from 'uuid';
+
+import BufferedEventEmitter from "./BufferedEventEmitter.js";
+
 import Symposium from "./Symposium.js";
 import Thread from "./Thread.js";
-import {v7 as uuid} from 'uuid';
 
 export default class Agent {
 	name = 'Agent';
@@ -11,13 +14,13 @@ export default class Agent {
 	tools = new Map();
 	default_model = 'gpt-4o';
 	max_retries = 5;
-	callbacks = {};
+	type = 'chat'; // chat, utility
 	utility = null;
+	initialized = false;
 
 	constructor(options) {
 		this.options = {
 			memory_handler: null,
-			interfaces: [],
 			...options,
 		};
 
@@ -25,11 +28,20 @@ export default class Agent {
 	}
 
 	async init() {
-		for (let i of this.options.interfaces)
-			await i.init(this);
+		if (this.initialized)
+			return;
 
 		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');
+		}
+
+		this.initialized = true;
 	}
 
 	async reset(thread) {
@@ -60,13 +72,10 @@ export default class Agent {
 	async doInitThread(thread) {
 	}
 
-	async getThread(id, i = 'default') {
+	async getThread(id) {
 		let thread = this.threads.get(id);
-		if (thread) {
-			if (thread.interface !== i)
-				throw new Error('Required thread is not from the same interface');
-		} else {
-			thread = new Thread(id, i, this);
+		if (!thread) {
+			thread = new Thread(id, this);
 
 			if (!(await thread.loadState())) {
 				await this.resetState(thread);
@@ -79,15 +88,14 @@ export default class Agent {
 		return thread;
 	}
 
-	async message(thread, i, content, callback = null) {
-		if (typeof thread !== 'object')
-			thread = await this.getThread(thread, i);
+	async message(content, thread = null) {
+		if (!this.initialized)
+			throw new Error('Agent not initialized');
 
-		if (callback) {
-			if (!this.callbacks.hasOwnProperty(i + '-' + thread.id))
-				this.callbacks[i + '-' + thread.id] = [];
-			this.callbacks[i + '-' + thread.id].push(callback);
-		}
+		if (thread === null)
+			thread = uuid();
+		if (typeof thread !== 'object')
+			thread = await this.getThread(thread);
 
 		const model = Symposium.getModelByName(thread.state.model);
 		if (!model.supports_audio && typeof content !== 'string') {
@@ -112,17 +120,14 @@ export default class Agent {
 		return thread;
 	}
 
-	async execute(thread, counter = 0) {
+	async execute(thread, counter = 0, existing_emitter = null) {
 		if (counter === 0)
 			thread = await this.beforeExecute(thread);
 
 		const model = Symposium.getModelByName(thread.state.model);
 
 		const completion_options = {};
-		if (this.utility) {
-			if (!['text', 'function', 'json'].includes(this.utility.type))
-				throw new Error('Bad utility definition');
-
+		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');
@@ -131,7 +136,7 @@ export default class Agent {
 				if (this.utility.type === 'json' && model.supports_structured_output)
 					response_format = this.convertFunctionToResponseFormat(this.utility.function.parameters);
 
-				if (response_format && response_format.count <= 100) { // Se ci sono più di 100 parametri, OpenAI non supporta gli structured output
+				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: {
@@ -149,30 +154,62 @@ export default class Agent {
 			}
 		}
 
-		const completion = await this.generateCompletion(thread, completion_options);
-		if (completion) {
-			try {
-				thread = await this.afterExecute(thread, completion);
-				const response = await this.handleCompletion(thread, completion);
-				switch (response.type) {
-					case 'return':
-						return response.value;
+		let completion;
+		try {
+			completion = await this.generateCompletion(thread, completion_options);
+		} catch (e) {
+			console.error(e.message);
+			switch (this.type) {
+				case 'chat':
+					const emitter = existing_emitter || new BufferedEventEmitter();
+					emitter.emit('error', e.message);
+					if (!existing_emitter)
+						emitter.emit('end');
+					return emitter;
+
+				case 'utility':
+					throw e;
+
+				default:
+					throw new Error('Bad agent type');
+			}
+		}
 
-					case 'continue':
-						return await this.execute(thread);
+		try {
+			thread = await this.afterExecute(thread, completion);
+			const emitter = this.handleCompletion(thread, completion, existing_emitter);
+
+			switch (this.type) {
+				case 'utility':
+					return new Promise((resolve, reject) => {
+						emitter.on('data', data => {
+							const parsed = JSON.parse(data);
+							if (parsed.type === 'response')
+								resolve(parsed.content);
+						});
+
+						emitter.on('error', error => reject(error));
+					});
 
-					case 'void':
-						return;
+				case 'chat':
+					if (!existing_emitter) {
+						emitter.on('data', data => {
+							const parsed = JSON.parse(data);
+							if (parsed.type === 'response' && parsed.content.type === 'continue')
+								this.execute(thread, 0, emitter);
+						}, false);
+					}
 
-					default:
-						throw new Error('Unknown response type');
-				}
-			} catch (e) {
-				console.error(e);
+					return emitter;
 
-				if (counter < this.max_retries)
-					await this.execute(thread, counter + 1);
+				default:
+					throw new Error('Bad agent type');
 			}
+		} catch (e) {
+			console.error(e);
+
+			if (counter < this.max_retries)
+				await this.execute(thread, counter + 1, existing_emitter);
 		}
 	}
 
@@ -180,11 +217,16 @@ export default class Agent {
 		if (obj.type !== 'object')
 			return {obj, count: 0};
 
-		let properties_count = 0, required = [];
+		let properties_count = 0, all_required = false, required = [];
+		if (obj.required)
+			required = obj.required;
+		else
+			all_required = true;
 
 		for (let [key, property] of Object.entries(obj.properties || {})) {
 			properties_count++;
-			required.push(key);
+			if (all_required)
+				required.push(key);
 
 			if (property.type === 'object') {
 				const {obj: subobj, count} = this.convertFunctionToResponseFormat(property);
@@ -232,43 +274,15 @@ export default class Agent {
 					return this.generateCompletion(thread, options, retry_counter + 1);
 				}
 
-				await this.error(thread, error.response.status + ': ' + JSON.stringify(error.response.data));
+				throw new Error(error.response.status + ': ' + JSON.stringify(error.response.data));
 			} else if (error.message) {
-				console.error(error.message);
-				await this.error(thread, error.message);
+				throw new Error(error.message);
 			} else {
-				console.error(error);
-				await this.error(thread, 'Errore interno');
+				throw new Error('Errore interno');
 			}
 		}
 	}
 
-	async error(thread, error) {
-		const i = this.options.interfaces.find(i => i.name === thread.interface);
-		if (i)
-			return i.error(thread, error);
-	}
-
-	async output(thread, msg) {
-		if (this.callbacks.hasOwnProperty(thread.interface + '-' + thread.id) && this.callbacks[thread.interface + '-' + thread.id].length) {
-			const callback = this.callbacks[thread.interface + '-' + thread.id].shift();
-			await callback(msg);
-		}
-
-		const i = this.options.interfaces.find(i => i.name === thread.interface);
-		if (i)
-			return i.output(thread, msg);
-	}
-
-	async partial(thread, msg) {
-		if ((typeof msg) === 'text')
-			msg = {summary: msg};
-
-		const i = this.options.interfaces.find(i => i.name === thread.interface);
-		if (i)
-			return i.partial(thread, msg);
-	}
-
 	parseFunctions(message) {
 		const newContent = [];
 		for (let m of message.content) {
@@ -294,9 +308,11 @@ export default class Agent {
 		return message;
 	}
 
-	async handleCompletion(thread, completion) {
+	async handleCompletion(thread, completion, existing_emitter = null) {
 		const model = Symposium.getModelByName(thread.state.model);
 
+		const emitter = existing_emitter || new BufferedEventEmitter();
+
 		const functions = [];
 		for (let message of completion) {
 			thread.addDirectMessage(message);
@@ -305,13 +321,21 @@ export default class Agent {
 			for (let m of message.content) {
 				switch (m.type) {
 					case 'text':
-						if (this.utility) {
+						if (this.type === 'utility') {
+							let response = null;
 							if (this.utility.type === 'text')
-								return this.afterHandle(thread, completion, 'return', m.content);
+								response = await this.afterHandle(thread, completion, 'return', m.content);
 							if (this.utility.type === 'json' && model.supports_structured_output)
-								return this.afterHandle(thread, completion, 'return', JSON.parse(m.content));
+								response = await this.afterHandle(thread, completion, 'return', JSON.parse(m.content));
+
+							if (response) {
+								emitter.emit('data', JSON.stringify({type: 'response', content: response}));
+								emitter.emit('end');
+								return emitter;
+							}
 						}
-						await this.output(thread, m.content);
+
+						emitter.emit('data', JSON.stringify({type: 'output', content: m.content}));
 						break;
 
 					case 'function':
@@ -322,28 +346,43 @@ export default class Agent {
 			}
 		}
 
+		let response;
 		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);
+				if (this.utility && ['function', 'json'].includes(this.utility.type)) {
+					response = this.afterHandle(thread, completion, 'return', f.arguments);
+					break;
+				}
 
-				const response = await this.callFunction(thread, f);
+				const function_response = await this.callFunction(thread, f, emitter);
 
 				thread.addMessage('tool', [
 					{
 						type: 'function_response',
-						content: {name: f.name, response, id: f.id || undefined},
+						content: {name: f.name, function_response, id: f.id || undefined},
 					},
 				], f.name);
 
-				await this.log('function_response', response);
+				await this.log('function_response', function_response);
 			}
 
-			return this.afterHandle(thread, completion, 'continue');
+			if (!response)
+				response = this.afterHandle(thread, completion, 'continue');
 		} else {
 			await thread.storeState();
-			return this.afterHandle(thread, completion, 'void');
+			response = this.afterHandle(thread, completion, 'void');
 		}
+
+		response
+			.then(content => {
+				emitter.emit('data', JSON.stringify({type: 'response', content}));
+				emitter.emit('end');
+			})
+			.catch(error => {
+				emitter.emit('error', error);
+			});
+
+		return emitter;
 	}
 
 	async afterHandle(thread, completion, type, value = null) {
@@ -376,23 +415,23 @@ export default class Agent {
 			return this.functions;
 	}
 
-	async callFunction(thread, function_call) {
+	async callFunction(thread, function_call, emitter) {
 		const functions = await this.getFunctions(false);
 		if (!functions.has(function_call.name))
 			throw new Error('Unrecognized function ' + function_call.name);
 
 		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 + '...';
-		this.partial(thread, partialOutput);
+		emitter.emit('data', JSON.stringify({type: 'partial', content: partialOutput}));
 
 		await this.log('function_call', function_call);
 
 		try {
 			const response = await func.tool.callFunction(thread, function_call.name, function_call.arguments);
-			this.partial(thread, 'Risposta ricevuta da ' + func.tool.name);
+			emitter.emit('data', JSON.stringify({type: 'partial', content: 'Risposta ricevuta da ' + func.tool.name}));
 			return response;
 		} catch (error) {
-			this.partial(thread, 'Ricevuto errore da ' + func.tool.name);
+			emitter.emit('data', JSON.stringify({type: 'partial', content: 'Ricevuto errore da ' + func.tool.name}));
 			return {error};
 		}
 	}
@@ -414,9 +453,15 @@ export default class Agent {
 		return [this.name];
 	}
 
-	async createRealtimeSession(thread_id = null, interface_name = 'default') {
+	async createRealtimeSession(thread_id = null, options = {}) {
+		options = {
+			include_thread: true,
+			language: 'it',
+			...options,
+		};
+
 		// Se viene passato un thread esistente, lo si usa, altrimenti si crea un nuovo thread temporaneo
-		const thread = await this.getThread(thread_id || uuid(), interface_name);
+		const thread = await this.getThread(thread_id || uuid());
 
 		const system_message = [], conversation = [];
 		for (let message of thread.messages) {
@@ -427,7 +472,7 @@ export default class Agent {
 		}
 
 		let instructions = system_message.join('\n');
-		if (conversation.length)
+		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 => ({
@@ -447,6 +492,7 @@ export default class Agent {
 				tools,
 				input_audio_transcription: {
 					model: 'gpt-4o-transcribe',
+					language: options.language,
 				},
 			}),
 		}).then(response => response.json());

package/BufferedEventEmitter.js

@@ -0,0 +1,28 @@
+import EventEmitter from 'events';
+
+export default class BufferedEventEmitter extends EventEmitter {
+	#buffer = [];
+
+	emit(eventName, ...args) {
+		if (this.listenerCount(eventName) > 0)
+			return super.emit(eventName, ...args);
+
+		this.#buffer.push({eventName, args});
+		return true;
+	}
+
+	#flush() {
+		for (const {eventName, args} of this.#buffer)
+			if (this.listenerCount(eventName) > 0)
+				super.emit(eventName, ...args);
+
+		this.#buffer = this.#buffer.filter(({eventName}) => this.listenerCount(eventName) === 0);
+	}
+
+	on(eventName, listener, flush = true) {
+		super.on(eventName, listener);
+		if (flush)
+			this.#flush();
+		return this;
+	}
+}

package/Symposium.js

@@ -1,23 +1,6 @@
 import fs from 'fs';
-
-import Gpt35 from "./models/Gpt35.js";
-import Gpt4 from "./models/Gpt4.js";
-import Gpt4Turbo from "./models/Gpt4Turbo.js";
-import Gpt4O from "./models/Gpt4O.js";
-import GptO1 from "./models/GptO1.js";
-import GptO1Mini from "./models/GptO1Mini.js";
-import Gpt5 from "./models/Gpt5.js";
-import Gpt5Mini from "./models/Gpt5Mini.js";
-import Whisper from "./models/Whisper.js";
-import Claude35Sonnet from "./models/Claude35Sonnet.js";
-import Claude37Sonnet from "./models/Claude37Sonnet.js";
-import Claude4Sonnet from "./models/Claude4Sonnet.js";
-import Claude4Opus from "./models/Claude4Opus.js";
-import Llama3 from "./models/Llama3.js";
-import Mixtral8 from "./models/Mixtral8.js";
-import DeepSeekChat from "./models/DeepSeekChat.js";
-import DeepSeekReasoner from "./models/DeepSeekReasoner.js";
-import Grok4 from "./models/Grok4.js";
+import path from 'path';
+import {fileURLToPath} from 'url';
 
 export default class Symposium {
 	static models = new Map();
@@ -31,28 +14,24 @@ export default class Symposium {
 	* - async set(key, value)
 	 */
 	static async init(storage = null) {
-		this.loadModel(new Gpt35());
-		this.loadModel(new Gpt4());
-		this.loadModel(new Gpt4Turbo());
-		this.loadModel(new Gpt4O());
-		this.loadModel(new GptO1());
-		this.loadModel(new GptO1Mini());
-		this.loadModel(new Whisper());
-		this.loadModel(new Gpt5());
-		this.loadModel(new Gpt5Mini());
-
-		this.loadModel(new Claude35Sonnet());
-		this.loadModel(new Claude37Sonnet());
-		this.loadModel(new Claude4Sonnet());
-		this.loadModel(new Claude4Opus());
-
-		this.loadModel(new Llama3());
-		this.loadModel(new Mixtral8());
-
-		this.loadModel(new DeepSeekChat());
-		this.loadModel(new DeepSeekReasoner());
-
-		this.loadModel(new Grok4());
+		const __filename = fileURLToPath(import.meta.url);
+		const __dirname = path.dirname(__filename);
+		const modelsPath = path.join(__dirname, 'models');
+
+		const modelFiles = await fs.promises.readdir(modelsPath);
+		for (const file of modelFiles) {
+			if (!file.endsWith('.js'))
+				continue;
+
+			const module = await import(`./models/${file}`);
+			const ModelClass = module.default;
+			if (ModelClass) {
+				const model = new ModelClass();
+				if (!model.name)
+					continue;
+				this.loadModel(model);
+			}
+		}
 
 		if (storage) {
 			this.storage = storage;
@@ -97,7 +76,7 @@ export default class Symposium {
 				if (!audio.data)
 					throw new Error('Audio URL is required');
 
-				if (audio.data.startsWith('/')) { // Local path
+				if (path.isAbsolute(audio.data)) { // Local path
 					// Get with fs
 					if (!fs.existsSync(audio.data))
 						throw new Error('Audio file does not exist at the specified path: ' + audio.data);

package/Thread.js

@@ -7,18 +7,15 @@ export default class Thread {
 	agent;
 	messages = [];
 	state = {};
-	interface = null;
 
-	constructor(id, i, agent) {
+	constructor(id, agent) {
 		this.id = id;
-		this.unique = agent.name + '-' + i + '-' + id;
+		this.unique = agent.name + '-' + id;
 		this.agent = agent;
-		this.interface = i;
 	}
 
 	clone(keepMessages = true) {
-		let newThread = new Thread(this.id, this.interface, this.agent);
-		newThread.interface = this.interface;
+		let newThread = new Thread(this.id, this.agent);
 		newThread.state = this.state;
 		if (keepMessages)
 			newThread.messages = [...this.messages];
@@ -27,7 +24,7 @@ export default class Thread {
 
 	changeId(id) {
 		this.id = id;
-		this.unique = this.agent.name + '-' + this.interface + '-' + id;
+		this.unique = this.agent.name + '-' + id;
 	}
 
 	async flush() {

package/index.js

@@ -7,7 +7,6 @@ import Tool from "./Tool.js";
 import Logger from "./Logger.js";
 import MemoryHandler from "./MemoryHandler.js";
 import Summarizer from "./Summarizer.js";
-import Interface from "./Interface.js";
 
 export {
 	Symposium,
@@ -17,5 +16,4 @@ export {
 	Logger,
 	MemoryHandler,
 	Summarizer,
-	Interface,
 };

package/package.json

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

package/Interface.js

@@ -1,15 +0,0 @@
-export default class Interface {
-	static name;
-
-	static async init(agent) {
-	}
-
-	static async output(thread, msg) {
-	}
-
-	static async partial(thread, msg) {
-	}
-
-	static async error(thread, error) {
-	}
-}

package/README.md

@@ -1,152 +0,0 @@
-# Symposium
-
-Symposium is an npm library designed to simplify the deployment and management of AI agents. Its modular and flexible architecture makes it easy to create agents that can interact with users, execute functions through integrated tools, and manage complex conversation threads—all while supporting multiple language models from various providers.
-
----
-
-Note: I am as lazy as all devs are, hence this README is written by an AI as well :)) I will improve it with time if needed 
-
----
-
-## Table of Contents
-
-- [Overview](#overview)
-- [Features](#features)
-- [Installation](#installation)
-- [Usage](#usage)
-- [Architecture](#architecture)
-- [Supported Models](#supported-models)
-- [Extending Symposium](#extending-symposium)
-- [Examples](#examples)
-- [Contributing](#contributing)
-- [License](#license)
-
----
-
-## Overview
-
-Symposium provides a robust framework for deploying AI agents with ease. It handles message threading, state management, logging, and even conversation summarization to keep interactions within token limits. With built-in support for multiple AI models and a plugin-like system for tools, Symposium enables developers to quickly build sophisticated agent-based applications.
-
----
-
-## Features
-
-- **Agent Management**: Create and manage agents that process user messages and execute actions.
-- **Tool Integration**: Extend your agents’ capabilities by integrating custom tools with defined functions.
-- **Thread & Memory Handling**: Manage conversation state and threads seamlessly, with automatic summarization support.
-- **Multi-Agent Coordination**: Support for multi-agent systems to allow agents to collaborate and share tasks.
-- **Flexible Model Support**: Out-of-the-box compatibility with various models including OpenAI, Anthropic, Groq, and DeepSeek.
-- **Structured Function Calls**: Enable agents to call functions using structured output, ensuring clarity and consistency.
-
----
-
-## Installation
-
-Install Symposium via npm:
-
-```bash
-npm install symposium
-```
-
----
-
-## Usage
-
-Below is a basic example of how to create a custom agent using Symposium:
-
-```js
-import { Symposium, Agent } from 'symposium';
-
-class MyAgent extends Agent {
-  constructor(options = {}) {
-    super(options);
-    this.name = 'MyAgent';
-  }
-
-  async doInitThread(thread) {
-    await thread.addMessage('system', 'Welcome! How can I assist you today?');
-  }
-}
-
-(async () => {
-  const myAgent = new MyAgent();
-  await myAgent.init();
-  
-  const thread = await myAgent.getThread('example-thread');
-  await myAgent.message(thread, 'default', 'Hello, agent!');
-})();
-```
-
----
-
-## Architecture
-
-Symposium is built around several core components:
-
-- **Agent**: The base class for creating agents. Agents process messages, manage threads, and interact with tools.
-- **Tool**: Extend functionality by integrating custom functions. Tools define their own functions and provide implementations through the `callFunction` method.
-- **Thread**: Represents a conversation, handling message storage, state management, and persistence.
-- **Logger & MemoryHandler**: Utilities for logging events and managing conversation memory, respectively.
-- **Summarizer**: A specialized memory handler that summarizes conversation threads to maintain context within token limits.
-- **Interface**: Abstracts output and error handling, enabling custom integrations with external systems.
-
----
-
-## Supported Models
-
-Symposium supports a variety of AI models, allowing you to switch between them based on your needs:
-
-- **OpenAI Models**:
-    - GPT-3.5-turbo
-    - GPT-4, GPT-4Turbo, GPT-4o
-    - GPT-o1, GPT-o1 mini
-- **Anthropic Models**:
-    - Claude variants (3.5 Sonnet, 3.7 Sonnet, 4 Sonnet, 4 Opus)
-- **Groq Models**:
-    - Llama3, Mixtral8
-- **DeepSeek Models**:
-    - DeepSeekChat, DeepSeekReasoner
-- **Other Models**:
-    - Whisper (for speech-to-text)
-
-These models are encapsulated in their own modules, and you can easily switch the active model by updating the conversation thread state.
-
----
-
-## Extending Symposium
-
-Symposium is designed to be extended and customized:
-
-- **Creating Custom Agents**: Inherit from the `Agent` class and override methods like `doInitThread` and `message` to implement custom behavior.
-- **Implementing Tools**: Build your own tools by extending the `Tool` class. Define the functions your tool exposes and provide implementations via `callFunction`.
-- **Custom Memory Handlers & Loggers**: Implement your own memory or logging strategies by creating classes that adhere to the respective interfaces.
-- **Defining Interfaces**: Customize output and error handling by implementing your own `Interface` classes.
-
----
-
-## Examples
-
-The repository includes an `examples` folder with sample implementations demonstrating:
-
-- **ChatAgent**: A basic conversational agent.
-- **MultiAgent**: An agent that coordinates with other agents via internal interfaces.
-- **TitlerAgent**: An agent that generates concise titles for conversations.
-- **Tools**: Examples like `GenericTool` and `MultiAgentTool` show how to integrate custom functionality.
-
-> **Important:** The content in the `examples` folder is provided solely for demo purposes and will not be part of the exported npm package. You can use these examples as a guide for building your own implementations.
-
----
-
-## Contributing
-
-Contributions to Symposium are welcome! If you have ideas, improvements, or bug fixes, please fork the repository and submit a pull request.
-
----
-
-## License
-
-Symposium is released under the ISC License.
-
----
-
-For more details or to report issues, please refer to the repository's issue tracker. Enjoy building your AI-driven applications with Symposium!

package/examples/ChatAgent.js

@@ -1,21 +0,0 @@
-import {Agent, Symposium} from "symposium";
-import GenericTool from "./Tools/GenericTool.js";
-
-export default class ChatAgent extends Agent {
-	default_model = 'gpt-4o';
-
-	constructor(options = {}) {
-		super(options);
-
-		this.name = 'ChatAgent';
-
-		this.addTool(new GenericTool());
-	}
-
-	async doInitThread(thread) {
-		await thread.addMessage('system',
-			`You are a helpful assistant, assist the user using the tools you are provided with.
-			Current time is: ${(new Date()).toLocaleDateString()}`
-		);
-	}
-}

package/examples/MultiAgent.js

@@ -1,115 +0,0 @@
-import {Agent, Symposium} from "symposium";
-import MultiAgentTool from "./Tools/MultiAgentTool.js";
-
-export default class MultiAgent extends Agent {
-	default_model = 'gpt-4o';
-
-	constructor(options = {}) {
-		options = {
-			agents: [],
-			...options,
-		};
-
-		super(options);
-		this.name = 'Multi Agent';
-
-		this.internalInterface = {
-			name: 'agent-vs-agent',
-			promises: [],
-			init: async () => {
-			},
-			message: async (thread, msg) => {
-			},
-			output: async (thread, msg) => {
-			},
-			error: async (thread, error) => {
-			},
-		};
-
-		this.addTool(new MultiAgentTool(this.options.agents));
-	}
-
-	async init() {
-		await super.init();
-
-		for (let agent of this.options.agents) {
-			agent.options.interfaces = [this.internalInterface];
-			await agent.init();
-		}
-	}
-
-	async reset(thread) {
-		await super.reset(thread);
-
-		for (let agent of this.options.agents) {
-			const sub_thread = await agent.getThread(thread.id, 'agent-vs-agent');
-			await agent.reset(sub_thread);
-		}
-	}
-
-	async doInitThread(thread) {
-		const memory = await this.tools.get('Memory').get();
-
-		await thread.addMessage('system',
-			`You are a helpful assistant, assist the user using the tools you are provided with.
-			In order to do so, you have a series of agents at your service, with which you can communicate behind the scenes to provide the user with what they asked for. You can communicate with them through their respective tools that you have.
-			You can talk to the agents in natural language, and also respond to them multiple times if necessary. Try to use clear and direct language with precise instructions when talking to an agent.
-			
-			At the end of each task, when the agent has completed its function, remember to reset the conversation with the agent to save memory. You can do this using the "reset" function.
-			
-			Interrogate them only if the user asks to perform tasks that concern them, otherwise you can rely on your knowledge to respond directly.
-			
-			Current time is: ${(new Date()).toLocaleDateString()}`,
-		);
-
-		for (let agent of this.options.agents) {
-			const sub_thread = await agent.getThread(thread.id, 'agent-vs-agent');
-			if (sub_thread) {
-				await sub_thread.flush();
-				await agent.initThread(sub_thread);
-			}
-		}
-	}
-
-	async beforeExecute(thread) {
-		if (this.options.reasoning) {
-			let reasoning = await this.generateCompletion(thread, {
-				functions: [
-					{
-						name: 'ragionamento',
-						description: 'Before responding to the user, ask yourself what needs to be done and if you need to ask for more info.',
-						parameters: {
-							type: 'object',
-							properties: {
-								ragionamento: {
-									type: 'string',
-									description: 'Reflect on the request just made. What do you need to do to fulfill the user\'s request? These are your thoughts and the user cannot see them.',
-								}
-							},
-							required: ['ragionamento'],
-						}
-					},
-					...(await this.getFunctions()),
-				],
-				force_function: 'ragionamento',
-			});
-
-			if (reasoning) {
-				reasoning = Symposium.extractFunctionsFromResponse(reasoning)[0];
-				await this.log('reasoning', reasoning);
-				thread.addMessage('assistant', "[Thinking] " + reasoning.ragionamento + "\n");
-			}
-		}
-
-		return thread;
-	}
-
-	async getPromptWordsForTranscription(thread) {
-		let words = [this.name];
-		for (let agent of this.options.agents) {
-			const sub_thread = await agent.getThread(thread.id, 'agent-vs-agent');
-			words = [...words, ...(await agent.getPromptWordsForTranscription(sub_thread))];
-		}
-		return words;
-	}
-}

package/examples/TitlerAgent.js

@@ -1,25 +0,0 @@
-import {Agent} from "symposium";
-
-export default class TitlerAgent extends Agent {
-	default_model = 'gpt-4o';
-
-	constructor(options) {
-		super(options);
-		this.name = 'Titler';
-	}
-
-	async init() {
-		await super.init();
-
-		this.utility = {
-			type: 'text',
-		};
-	}
-
-	async doInitThread(thread) {
-		await thread.addMessage('system',
-			`Your task is to observe the following message, which represents the beginning of a conversation from the user, and give a title of a few words (maximum 30 characters) that describes it as accurately as possible. Even a single word is fine, if necessary.
-			Do not write anything else in your message, but only and exclusively the title.`
-		);
-	}
-}

package/examples/Tools/GenericTool.js

@@ -1,42 +0,0 @@
-import {Tool} from "symposium";
-
-export default class GenericTool extends Tool {
-	name = 'GenericTool';
-
-	async getFunctions() {
-		return [
-			{
-				name: `create_todo`,
-				description: `Create a new TODO`,
-				parameters: {
-					type: 'object',
-					properties: {
-						title: {
-							type: 'string',
-							description: 'Title of the TODO',
-						},
-						description: {
-							type: 'string',
-							description: 'Description of the TODO',
-						},
-						due_date: {
-							type: 'string',
-							description: 'Due date of the TODO',
-						},
-					},
-					required: ['title', 'description', 'due_date'],
-				},
-			}
-		];
-	}
-
-	async callFunction(thread, name, payload) {
-		try {
-			// Implement your function here
-
-			throw new Error(`Unknown function: ${name}`);
-		} catch (error) {
-			return {error: error.response?.body || error};
-		}
-	}
-}

package/examples/Tools/MultiAgentTool.js

@@ -1,77 +0,0 @@
-import {Tool} from "symposium";
-
-export default class MultiAgentTool extends Tool {
-	name = 'MultiAgentTool';
-	agents;
-
-	constructor(agents) {
-		super();
-		this.agents = agents;
-	}
-
-	async getFunctions() {
-		return [
-			...this.agents.map(a => ({
-				name: a.name,
-				description: a.description,
-				parameters: {
-					type: 'object',
-					properties: {
-						message: {
-							type: 'string',
-							description: 'The message to send to the agent'
-						}
-					}
-				}
-			})),
-			{
-				name: 'reset',
-				description: 'Reset an agent\'s memory to start the conversation again',
-				parameters: {
-					type: 'object',
-					properties: {
-						agent: {
-							type: 'string',
-							description: 'The name of the agent to reset'
-						}
-					}
-				}
-			}
-		];
-	}
-
-	async callFunction(thread, name, payload) {
-		try {
-			if (name === 'reset') {
-				const agent = this.agents.find(a => a.name === payload.agent);
-				if (!agent)
-					throw new Error('No agent named "' + payload.agent + '"');
-
-				const sub_thread = await agent.getThread(thread.id, 'agent-vs-agent');
-
-				await agent.reset(sub_thread);
-
-				return {success: true};
-			} else {
-				const agent = this.agents.find(a => a.name === name);
-				if (!agent)
-					throw new Error('No agent named "' + name + '"');
-
-				return await (new Promise(async (resolve, reject) => {
-					try {
-						const sub_thread = await agent.getThread(thread.id, 'agent-vs-agent');
-
-						await agent.message(sub_thread, 'agent-vs-agent', payload.message, msg => {
-							resolve({reply: msg});
-						});
-					} catch (e) {
-						console.error(JSON.stringify(e));
-						reject(e);
-					}
-				}));
-			}
-		} catch (error) {
-			return {error};
-		}
-	}
-}