symposium 0.7.5 → 0.8.0

package/Agent.js

@@ -7,7 +7,6 @@ export default class Agent {
 	options = {};
 	threads;
 	functions = null;
-	middlewares = new Map();
 	tools = new Map();
 	default_model = 'gpt-4-turbo';
 
@@ -43,10 +42,6 @@ export default class Agent {
 		this.tools.set(tool.name, tool);
 	}
 
-	addMiddleware(middleware) {
-		this.middlewares.set(middleware.name, middleware);
-	}
-
 	async initThread(thread) {
 		await this.doInitThread(thread);
 		await thread.storeState();
@@ -97,27 +92,9 @@ export default class Agent {
 		if (this.options.memory_handler)
 			thread = await this.options.memory_handler.handle(thread);
 
-		for (let middleware of this.middlewares.values()) {
-			let proceed = await middleware.before_exec(thread);
-			if (!proceed) {
-				await thread.storeState();
-				return;
-			}
-		}
-
 		const completion = await this.generateCompletion(thread);
-
 		if (completion)
 			await this.handleCompletion(thread, completion);
-
-		const reversedMiddlewares = [...this.middlewares.values()];
-		reversedMiddlewares.reverse();
-
-		for (let middleware of reversedMiddlewares) {
-			let proceed = await middleware.after_exec(thread);
-			if (!proceed)
-				return;
-		}
 	}
 
 	async generateCompletion(thread, options = {}, retry_counter = 1) {

package/Summarizer.js

@@ -13,11 +13,16 @@ export default class Summarizer extends MemoryHandler {
 		if (!model)
 			return thread;
 
-		const tokens = await model.countTokens(thread);
-		if (tokens >= model.tokens * this.threshold)
-			return await this.summarize(model, thread, model.tokens * this.summary_length);
-		else
+		try {
+			const tokens = await model.countTokens(thread);
+			if (tokens >= model.tokens * this.threshold)
+				return await this.summarize(model, thread, model.tokens * this.summary_length);
+			else
+				return thread;
+		} catch (e) {
+			console.error('Summarizer error: ' + String(e));
 			return thread;
+		}
 	}
 
 	async summarize(model, thread, maxLength) {

package/Symposium.js

@@ -6,6 +6,8 @@ import Whisper from "./models/Whisper.js";
 import Claude3Haiku from "./models/Claude3Haiku.js";
 import Claude3Sonnet from "./models/Claude3Sonnet.js";
 import Claude3Opus from "./models/Claude3Opus.js";
+import Llama3 from "./models/Llama3.js";
+import Mixtral8 from "./models/Mixtral8.js";
 
 export default class Symposium {
 	static models = new Map();
@@ -20,6 +22,9 @@ export default class Symposium {
 		this.loadModel(new Claude3Sonnet());
 		this.loadModel(new Claude3Opus());
 
+		this.loadModel(new Llama3());
+		this.loadModel(new Mixtral8());
+
 		return Redis.init();
 	}
 

package/index.js

@@ -3,11 +3,9 @@
 import Symposium from "./Symposium.js";
 import Agent from "./Agent.js";
 import Thread from "./Thread.js";
-import Message from "./Message.js";
 import Tool from "./Tool.js";
 import Logger from "./Logger.js";
 import MemoryHandler from "./MemoryHandler.js";
-import Middleware from "./Middleware.js";
 import Summarizer from "./Summarizer.js";
 
 export {
@@ -17,6 +15,5 @@ export {
 	Tool,
 	Logger,
 	MemoryHandler,
-	Middleware,
 	Summarizer,
 };

package/models/GroqModel.js

@@ -0,0 +1,156 @@
+import Model from "../Model.js";
+import Groq from "groq-sdk";
+import Message from "../Message.js";
+
+export default class GroqModel extends Model {
+	groq;
+	supports_functions = true;
+
+	getGroq() {
+		if (!this.groq)
+			this.groq = new Groq();
+
+		return this.groq;
+	}
+
+	async generate(thread, functions = [], options = {}) {
+		const parsed = this.parseOptions(options, functions);
+		options = parsed.options;
+		functions = parsed.functions;
+
+		let messages = thread.messages;
+
+		if (functions.length && !this.supports_functions) {
+			// 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));
+
+		const completion_payload = {
+			model: this.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 (!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 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),
+		];
+	}
+
+	convertMessage(message) {
+		const messages = [];
+		for (let c of message.content) {
+			switch (c.type) {
+				case 'text':
+					messages.push({
+						role: message.role,
+						content: c.content,
+						name: message.name,
+					});
+					break;
+
+				case 'image':
+					throw new Error('Images not supported by this model');
+
+				case 'function':
+					if (this.supports_functions) {
+						messages.push({
+							role: message.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: message.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 (this.supports_functions) {
+						messages.push({
+							role: message.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/Llama3.js

@@ -0,0 +1,7 @@
+import GroqModel from "./GroqModel.js";
+
+export default class Llama3 extends GroqModel {
+	name = 'llama3-70b-8192';
+	label = 'llama-3';
+	tokens = 8192;
+}

package/models/Mixtral8.js

@@ -0,0 +1,7 @@
+import GroqModel from "./GroqModel.js";
+
+export default class Mixtral8 extends GroqModel {
+	name = 'mixtral-8x7b-32768';
+	label = 'mixtral-8';
+	tokens = 32768;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "symposium",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",
@@ -9,6 +9,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.20.0",
     "@travio/redis": "^2.0.0",
+    "groq-sdk": "^0.3.2",
     "openai": "^4.12.1",
     "tiktoken": "^1.0.10"
   }

package/Middleware.js

@@ -1,16 +0,0 @@
-export default class Middleware {
-	name;
-	agent;
-
-	constructor(agent) {
-		this.agent = agent;
-	}
-
-	async before_exec(thread) {
-		return true;
-	}
-
-	async after_exec(thread) {
-		return true;
-	}
-}