symposium 0.7.4 → 0.7.6

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/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.4",
+  "version": "0.7.6",
   "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"
   }