symposium 1.0.4 → 1.1.0

package/Agent.js

@@ -4,6 +4,8 @@ import BufferedEventEmitter from "./BufferedEventEmitter.js";
 
 import Symposium from "./Symposium.js";
 import Thread from "./Thread.js";
+import Tool from "./Tool.js";
+import Context from "./Context.js";
 
 export default class Agent {
 	name = 'Agent';
@@ -12,6 +14,7 @@ export default class Agent {
 	threads;
 	functions = null;
 	tools = new Map();
+	context = [];
 	default_model = 'gpt-4o';
 	max_retries = 5;
 	type = 'chat'; // chat, utility
@@ -61,18 +64,58 @@ export default class Agent {
 	}
 
 	addTool(tool) {
+		if (!(tool instanceof Tool) || !tool.name)
+			throw new Error('Tool must be an instance of Tool class');
+		if (this.tools.has(tool.name))
+			throw new Error('Tool with name ' + tool.name + ' already exists in agent');
+
 		this.tools.set(tool.name, tool);
 	}
 
+	addContext(context) {
+		if (!(context instanceof Context))
+			throw new Error('Context must be an instance of Context class');
+
+		// TODO: on-request contexts
+		// TODO: summarization based on tokens
+		// TODO: RAG
+
+		this.context.push(context);
+	}
+
 	async initThread(thread) {
 		await this.doInitThread(thread);
+
+		const context_texts = [];
+		for (let context of this.context) {
+			const text = await context.getText();
+			if (text)
+				context_texts.push('<context>' + text + '</context>');
+		}
+
+		if (context_texts.length) {
+			let system_message_found = null;
+			for (let messages of thread.messages) {
+				if (messages.role === 'system')
+					system_message_found = messages;
+			}
+
+			if (system_message_found)
+				system_message_found.content[0].content += '<context_info>' + context_texts.join('\n') + '</context_info>';
+			else
+				thread.addMessage('system', '<context_info>' + context_texts.join('\n') + '</context_info>');
+		}
+
 		await thread.storeState();
 	}
 
 	async doInitThread(thread) {
 	}
 
-	async getThread(id) {
+	async getThread(id = null) {
+		if (id === null)
+			id = uuid();
+
 		let thread = this.threads.get(id);
 		if (!thread) {
 			thread = new Thread(id, this);

package/Context.js

@@ -0,0 +1,8 @@
+export default class Context {
+	/**
+	 * @returns {Promise<string|null>}
+	 */
+	async getText() {
+		return null;
+	}
+}

package/{MemoryHandler.js → ContextHandler.js}

@@ -1,4 +1,4 @@
-export default class MemoryHandler {
+export default class ContextHandler {
 	agent = null;
 
 	setAgent(agent) {

package/Contexts/File.js

@@ -0,0 +1,20 @@
+import fs from "fs";
+import Context from "../Context.js";
+
+export default class File extends Context {
+	constructor(file) {
+		super();
+		this.file = file;
+	}
+
+	async getText() {
+		if (this.file.startsWith('http://') || this.file.startsWith('https://')) {
+			return fetch(this.file);
+		} else {
+			if (fs.existsSync(this.file))
+				return fs.promises.readFile(this.file, "utf8");
+			else
+				throw new Error(`File not found: ${this.file}`);
+		}
+	}
+}

package/README.md

@@ -38,7 +38,7 @@ The framework is built around a few core components:
 -   **`Thread`**: Represents a single conversation with an agent. It maintains the message history and the agent's state for that conversation. Each thread has a unique ID.
 -   **`Tool`**: A base class for creating tools that an `Agent` can use. Tools expose functions that the LLM can call to interact with external APIs or data.
 -   **`Message`**: A wrapper for messages within a `Thread`, containing the role (`user`, `assistant`, `system`, `tool`), content, and other metadata.
--   **`MemoryHandler`**: A class for managing an agent's long-term memory. It can be extended to create custom memory strategies.
+-   **`ContextHandler`**: A class for managing an agent's long contexts. It can be extended to create custom memory strategies.
 -   **`Summarizer`**: A utility agent for summarizing text or conversations.
 -   **`Logger`**: A simple logging utility that can be passed to an agent to log its activity.
 
@@ -62,9 +62,41 @@ async function main() {
 main();
 ```
 
-### 2. Create your Agent
+### 2. One shot prompts
 
-Create a new class that extends `Agent`. At a minimum, you'll want to define a name and a system prompt.
+You can also use the static `Symposium.prompt()` method for one-off prompts without creating an agent.
+
+```javascript
+import { Symposium } from 'symposium';
+await Symposium.init();
+
+const response = await Symposium.prompt('Translate the text from English to French.', 'Hello, how are you?');
+console.log(response); // "Bonjour, comment ça va?"
+
+const structured_response = await Symposium.prompt('Extract name and emails from the following email', email_text, {
+	response: {
+		type: 'json',
+        function: {
+            name: 'extract_data',
+            parameters: {
+                type: 'array',
+                items: {
+	                type: 'object',
+	                properties: {
+		                name: {type: 'string'},
+		                email: {type: 'string'},
+	                },
+	                required: ['name', 'email'],
+                },
+            },
+        },
+    },
+});
+```
+
+### 3. Create your Agent
+
+For more structured and/or reusable tasks, create a new class that extends `Agent`. At a minimum, you'll want to define a name and a system prompt.
 
 ```javascript
 // MyChatAgent.js
@@ -80,7 +112,7 @@ export default class MyChatAgent extends Agent {
 }
 ```
 
-### 3. Start a Conversation
+### 4. Start a Conversation
 
 Now you can instantiate your agent and start a conversation.
 
@@ -338,7 +370,7 @@ This is a high-level overview. For details, please refer to the source code.
 
 ### Other Classes
 
--   **`MemoryHandler`**: Provides a base for implementing long-term memory for an agent.
+-   **`ContextHandler`**: Provides a base for managing long-term context. Can be extended for custom memory strategies.
 -   **`Summarizer`**: A utility agent for text summarization.
 -   **`Logger`**: A simple logger for agent activity.
 

package/Summarizer.js

@@ -1,7 +1,7 @@
 import Symposium from "./Symposium.js";
-import MemoryHandler from "./MemoryHandler.js";
+import ContextHandler from "./ContextHandler.js";
 
-export default class Summarizer extends MemoryHandler {
+export default class Summarizer extends ContextHandler {
 	constructor(threshold = 0.7, summary_length = 0.5) {
 		super();
 		this.threshold = threshold;

package/Symposium.js

@@ -2,6 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import {fileURLToPath} from 'url';
 
+import Agent from "./Agent.js";
+
 export default class Symposium {
 	static models = new Map();
 	static storage = null;
@@ -113,4 +115,19 @@ export default class Symposium {
 
 		return mimeToExt[mime] || null;
 	}
+
+	static async prompt(system, prompt, options = {}) {
+		const agent = new Agent(options.agent || {});
+		agent.type = 'utility';
+		agent.utility = options.response || {
+			type: 'text',
+		};
+
+		agent.doInitThread = async thread => {
+			await thread.addMessage('system', system);
+		};
+
+		const thread = await agent.getThread();
+		return agent.message(prompt, thread);
+	}
 }

package/index.js

@@ -5,7 +5,7 @@ import Agent from "./Agent.js";
 import Thread from "./Thread.js";
 import Tool from "./Tool.js";
 import Logger from "./Logger.js";
-import MemoryHandler from "./MemoryHandler.js";
+import ContextHandler from "./ContextHandler.js";
 import Summarizer from "./Summarizer.js";
 
 export {
@@ -14,6 +14,6 @@ export {
 	Thread,
 	Tool,
 	Logger,
-	MemoryHandler,
+	ContextHandler,
 	Summarizer,
 };

package/package.json

@@ -1,16 +1,16 @@
 {
   "type": "module",
   "name": "symposium",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Agents",
   "main": "index.js",
   "author": "Domenico Giambra",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.60.0",
-    "groq-sdk": "^0.30.0",
+    "@anthropic-ai/sdk": "^0.64.0",
+    "groq-sdk": "^0.32.0",
     "openai": "^5.0.0",
     "tiktoken": "^1.0.10",
-    "uuid": "^11.1.0"
+    "uuid": "^13.0.0"
   }
 }