symposium 0.5.2 → 0.5.4

package/Model.js

@@ -1,9 +1,6 @@
-import Message from "./Message.js";
-
 export default class Model {
 	type = 'llm';
 	name;
-	name_for_tiktoken;
 	label;
 	tokens;
 	supports_functions = false;
@@ -11,27 +8,40 @@ export default class Model {
 	constructor() {
 		if (!this.label)
 			this.label = this.name;
-		if (!this.name_for_tiktoken)
-			this.name_for_tiktoken = this.name;
 	}
 
 	async generate(thread, payload = {}, functions = []) {
 		return null;
 	}
 
-	promptFromFunctions(functions) {
+	async countTokens(thread) {
+		throw new Error('countTokens not implemented in this model');
+	}
+
+	promptFromFunctions(payload, functions) {
+		if (payload.function_call)
+			functions = functions.filter(f => f.name !== payload.function_call);
+
 		if (!functions.length)
 			return '';
 
-		let message = "Hai a disposizione alcune funzioni che puoi chiamare per ottenere risposte o compiere azioni. Ricorda che devi attendere la risposta dalla funzione per sapere se ha avuto successo. Per chiamare una funzione scrivi un messaggio che inizia con CALL nome_funzione e a capo inserisci il JSON con gli argomenti; delimitando il tutto da 3 caratteri ``` - ad esempio:\n" +
-			"```\n" +
-			"CALL create_user\n" +
-			'{"name":"test"}' + "\n" +
-			"```\n\n" +
-			"Lista delle funzioni che hai a disposizione:\n";
-
-		for (let f of functions)
-			message += '- ' + f.name + "\n " + f.description + "\n";
+		let message;
+		if (payload.function_call) {
+			message = "Nella prossima risposta, rispondi UNICAMENTE seguendo le seguenti istruzioni:\n";
+			message += functions[0].description + "\n";
+			delete functions[0].description;
+			message += "Rispondi con un messaggio che inizia con le parole:\nCALL " + payload.function_call + "\nE poi a capo un oggetto JSON che segue queste direttive OpenAPI:\n";
+		} else {
+			message = "Hai a disposizione alcune funzioni che puoi chiamare per ottenere risposte o compiere azioni. Ricorda che devi attendere la risposta dalla funzione per sapere se ha avuto successo. Per chiamare una funzione scrivi un messaggio che inizia con CALL nome_funzione e a capo inserisci il JSON con gli argomenti; delimitando il tutto da 3 caratteri ``` - ad esempio:\n" +
+				"```\n" +
+				"CALL create_user\n" +
+				'{"name":"test"}' + "\n" +
+				"```\n\n" +
+				"Lista delle funzioni che hai a disposizione:\n";
+
+			for (let f of functions)
+				message += '- ' + f.name + "\n " + f.description + "\n";
+		}
 
 		message += "\nOpenAPI specs:\n\n";
 		for (let f of functions) {
@@ -40,6 +50,9 @@ export default class Model {
 			message += '=== ' + f.name + " ===\n" + JSON.stringify(f.parameters.properties) + "\n\n";
 		}
 
+		if (payload.function_call)
+			message += "\nNella risposta non deve esserci NIENTE ALTRO se non queste due cose, non saranno prese in considerazione dal sistema altro genere di risposte.";
+
 		return message;
 	}
 }

package/Summarizer.js

@@ -1,6 +1,5 @@
 import Symposium from "./Symposium.js";
 import MemoryHandler from "./MemoryHandler.js";
-import {encoding_for_model} from "tiktoken";
 
 export default class Summarizer extends MemoryHandler {
 	constructor(threshold = 0.7, summary_length = 0.5) {
@@ -14,19 +13,14 @@ export default class Summarizer extends MemoryHandler {
 		if (!model)
 			return thread;
 
-		const encoder = encoding_for_model(model.name_for_tiktoken);
-		const tokens = this.countTokens(encoder, thread);
+		const tokens = await model.countTokens(thread);
 		if (tokens >= model.tokens * this.threshold)
-			return await this.summarize(encoder, thread, model.tokens * this.summary_length);
+			return await this.summarize(model, thread, model.tokens * this.summary_length);
 		else
 			return thread;
 	}
 
-	countTokens(encoder, thread) {
-		return encoder.encode(thread.messages.map(m => m.text).join('')).length;
-	}
-
-	async summarize(encoder, thread, maxLength) {
+	async summarize(model, thread, maxLength) {
 		let summaryThread = thread.clone(false);
 
 		let currentStep = 'system';
@@ -37,7 +31,7 @@ export default class Summarizer extends MemoryHandler {
 						currentStep = 'summary';
 					break;
 				case 'summary':
-					if (message.role === 'user' && this.hasPassedLimit(encoder, summaryThread, maxLength)) {
+					if (message.role === 'user' && (await this.hasPassedLimit(model, summaryThread, maxLength))) {
 						summaryThread = await this.doSummarize(summaryThread, maxLength);
 						currentStep = 'retain';
 					}
@@ -50,8 +44,8 @@ export default class Summarizer extends MemoryHandler {
 		return summaryThread;
 	}
 
-	hasPassedLimit(encoder, thread, maxLength) {
-		let length = this.countTokens(encoder, thread);
+	async hasPassedLimit(model, thread, maxLength) {
+		const length = await model.countTokens(thread);
 		return length > maxLength;
 	}
 
@@ -79,13 +73,16 @@ export default class Summarizer extends MemoryHandler {
 		if (!summary)
 			return false;
 
-		// TODO: sistemare con nuova interfaccia
 		let summarizedThread = thread.clone(false);
 		for (let message of thread.messages) {
 			if (message.role === 'system' && !message.tags.includes('summary')) {
 				summarizedThread.messages.push(message);
 			} else {
-				summarizedThread.addMessage('system', "This is what happened until now:\n" + summary.function_call.arguments.summary, ['summary']);
+				const functionResponse = Symposium.extractFunctionFromResponse(summary);
+				if (functionResponse)
+					throw new Error('Errore durante la generazione di un riassunto interno');
+
+				summarizedThread.addMessage('system', "This is what happened until now:\n" + functionResponse.summary, undefined, ['summary']);
 				break;
 			}
 		}

package/Symposium.js

@@ -36,4 +36,14 @@ export default class Symposium {
 	static getModelByLabel(label) {
 		return Array.from(this.models.values()).find(model => model.label === label);
 	}
+
+	static extractFunctionFromResponse(messages) {
+		for (let message of messages) {
+			const functionResponse = message.content.filter(c => c.type === 'function');
+			if (functionResponse.length)
+				return functionResponse[0].arguments;
+		}
+
+		return null;
+	}
 }

package/models/AnthropicModel.js

@@ -18,7 +18,7 @@ export default class AnthropicModel extends Model {
 
 		if (functions.length && !this.supports_functions) {
 			// Se il modello non supporta nativamente le funzioni, aggiungo il prompt al messaggio di sistema
-			const functions_prompt = this.promptFromFunctions(functions);
+			const functions_prompt = this.promptFromFunctions(payload, functions);
 			system += "\n\n" + functions_prompt;
 			functions = [];
 		}

package/models/OpenAIModel.js

@@ -1,11 +1,19 @@
 import Model from "../Model.js";
 import OpenAI from "openai";
 import Message from "../Message.js";
+import {encoding_for_model} from "tiktoken";
 
 export default class OpenAIModel extends Model {
 	openai;
+	name_for_tiktoken;
 	supports_functions = true;
 
+	constructor() {
+		super();
+		if (!this.name_for_tiktoken)
+			this.name_for_tiktoken = this.name;
+	}
+
 	getOpenAi() {
 		if (!this.openai)
 			this.openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});
@@ -74,6 +82,15 @@ export default class OpenAIModel extends Model {
 		];
 	}
 
+	async countTokens(thread) {
+		const encoder = encoding_for_model(this.name_for_tiktoken);
+
+		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;
+	}
+
 	convertMessage(message) {
 		const messages = [];
 		for (let c of message.content) {

package/package.json

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