@j-o-r/hello-dave 0.0.0

package/lib/AgentManager.js

@@ -0,0 +1,144 @@
+import { Prompt, Cli, AgentClient, AgentServer, API, ToolSet, Session, env } from './index.js';
+import toolsPool from './genericToolset.js'
+/**
+* @typedef {import('./API/x.ai/text.js').XOptions} XOptions
+* @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
+* @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
+*/
+/**
+* @typedef {Object} Setup
+* @property {string} prompt - Initial system prompt
+* @property {OAOptions|XOptions|ANTHOptions} options - Model options
+* @property {'gpt'|'grok'|'claude'} api - AI endpoint to use
+* @property {number} [contextWindow] - The size in tokens for the context/session
+* @property {'auto'|'required'|void} [toolsetMode] - 
+* @property {boolean} [debug] - verbose output
+*/
+/**
+* @typedef {Object} Options
+* @property {string} name - Agent name
+* @property {string} [cachePath] - path to session/record storage 
+*/
+class AgentManager {
+	/** @type {Prompt} */
+  #prompt;
+  /** @type {Session} */
+  #sessionStorage;
+  #name = 'agent';
+  #cachePath = '.cache/hello-dave';
+  #debug = false;
+  /**
+  * @param {Options} options
+  */
+  constructor(options) {
+    this.#name = options.name || this.#name;
+    this.#cachePath = options.cachePath || this.#cachePath;
+  }
+
+  /**
+  * @param {Setup} setup
+  */
+  setup(setup) {
+    const {
+    	prompt,
+    	api = 'gpt',
+    	contextWindow = 300000,
+    	options = null,
+    	toolsetMode = null,
+    	debug = false
+    } = setup;
+    let toolset;
+    if (toolsetMode) {
+    	toolset = new ToolSet(toolsetMode);
+    }
+    if (debug) {
+    	this.#debug = true;
+    }
+    this.#prompt = new Prompt(contextWindow);
+    this.#sessionStorage = new Session(this.#name, this.#prompt, this.#cachePath);
+    this.#prompt.add('system', prompt, true);
+    this.#prompt.setAdaptor(API.text[api], toolset, options);
+    return this; // For chaining
+  }
+
+  /**
+  * Start a CLI for local usage
+  * @param {string} description - introduction message for the CLI user
+  */
+  startCli(description) {
+    if (!this.#prompt) throw new Error('Run setup first');
+    const cli = new Cli({ prompt: this.#prompt, session: this.#sessionStorage, description });
+    setTimeout(() => {
+      // This resolves issues with log output after the console has been started
+      cli.start();
+    }, 1000);
+  }
+
+  /**
+  * Attach a session to an AgentServer
+  * DO NOT ATTACH TO SELF, however, when in server mode
+  * An AgentServer can attach as client to another server
+  * @param {string} name - function_call name
+  * @param {string} description - function_call description
+  * @param {string} [url='ws://127.0.0.1:8000/ws'] - ws URL
+  */
+  attach(name, description, url = 'ws://127.0.0.1:8000/ws') {
+    if (!this.#prompt) throw new Error('Run setup first');
+    return new AgentClient({ prompt: this.#prompt, name, description, url });
+  }
+
+  /**
+  * Start the Agent in server mode.
+  * A server is always started on localhost
+  * Clients can attach now and are accesible as via function_calls (toolset)  
+  * @param {string} name - function_call name
+  * @param {string} description - function_call description
+  * @param {number} [port=8000] - Start the dynamic toolset server on this port
+  */
+  enableServer(name, description = '', port = 8000) {
+    if (!this.#prompt) throw new Error('Run setup first');
+    if (!this.#prompt.toolset) throw new Error('No toolset defined');
+    const server = new AgentServer({
+    	port,
+    	name,
+    	description,
+    	prompt: this.#prompt,
+    	session: this.#sessionStorage,
+    	debug: this.#debug
+    	
+    });
+    // trigger reset on all Agents
+    this.#prompt.on('reset', () => {
+    	// Generate new context for all Agents
+    	server.resetAll();
+    })
+  }
+  /**
+  * Direct call to the prompt
+  * @param {string} input
+  * @returns {Promise<string>}
+  */
+  async directCall(input) {
+		const res = await this.#prompt.call(input);
+  	return res;
+  }
+  /** @returns {Prompt} */
+  getPrompt() { return this.#prompt; }
+  /** @returns {ToolSet|void} */
+  getToolset() { return this.#prompt.toolset; }
+  /** @returns {Promise<import('./fafs.js').EnvironmentInfo>} */
+  async environment() {
+  	return env();
+  }
+  /**
+  * @param {string} name - the toolname
+  */
+  addGenericToolcall(name) {
+    if (!this.#prompt.toolset) throw new Error('No ToolSet defined')
+    let tool  = toolsPool.get(name);
+    if (!tool) throw new Error('Tool not defined')
+  	this.#prompt.toolset.add(name, tool.description, tool.parameters, tool.method);
+  }
+}
+
+export default AgentManager;

package/lib/AgentServer.js

@@ -0,0 +1,336 @@
+import { WebSocketServer, server } from '@j-o-r/apiserver';
+
+const TIMEOUT = 30000;
+const MAX_INTERVALS = 20; // 10 minutes (30 sec * 20) 
+
+let ws;
+/**
+@typedef  {import('../node_modules/@j-o-r/apiserver/types/ClientWrapper.d.ts').ClientWrapper} Client 
+@typedef {import('./Prompt.js').default} Prompt
+@typedef {import('./ToolSet.js').default} ToolSet
+@typedef {import('./Session.js').default} Session
+*/
+/**
+* @type {string|object} messageContent
+*/
+/**
+* @type {Object} message
+* @property {string} action
+* @property {messageContent} content
+*/
+/**
+* @typedef {(conn: import('@j-o-r/apiserver/types/WebSocketServer.js').WebSocketConnection) => Promise<boolean>} AuthFunction
+*/
+/**
+* @typedef {Object} AgentServerOptions
+* @property {string} name
+* @property {string} description
+* @property {Prompt} prompt
+* @property {Session} session
+* @property {AuthFunction} [auth]
+* @property {number} [port] - default 8000
+* @property {boolean} [debug = false] 
+*/
+
+ const ACTIONS = [
+	// Agent / Toolset function calls
+	'agent_introduction', // Describe your task, your purpose and usage. This is a reaction on a 'introduce' requests
+	'agent_error',        // Message error
+	'agent_query',        // doing a query
+	'agent_response',     // Doing an response on a query
+	// Regular user interaction
+	'user_introduction',  // Websocket client connection on open
+	'user_request',       // A client user request
+	'server_response',    // A reponse to a user request
+	'user_reset',         // User requests a new session
+	'user_sessionlist',   // Request a list of sessions
+	'user_loadsession',   // Request to load a session
+	'user_info',          // User request server info
+];
+
+
+
+
+// WS clients 
+const clients = new Map();
+// Pending  messages
+const pendingResponses = new Map(); // key: `${conn_id}:${msg_id}`, value: {resolve, reject}
+
+/**
+* Delete a client from the toolset
+* @param {ToolSet|void} toolset
+* @param {string} conn_id - Connection id
+*/
+const deleteClient = (toolset, conn_id) => {
+	if (!toolset) return;
+	const name = clients.get(conn_id);
+	if (name) {
+		clients.delete(conn_id);
+		if (toolset.has(name)) {
+			toolset.delete(name);
+		}
+	}
+}
+/**
+* @param {ToolSet|void} toolset
+* @param {string} conn_id - Connection id
+* @param {string} name - logical name / task
+* @param {string} description of the logical name
+*/
+const addClient = (toolset, conn_id, name, description) => {
+	if (!toolset) return;
+	toolset.add(
+		name,
+		description,
+		{
+			type: 'object',
+			properties: {
+				query: {
+					type: 'string',
+					description: `Command, question or query for this particulair expert well formed in natural language`
+				}
+			},
+			required: ['query']
+		},
+		// @ts-ignore
+		(params) => {
+			return new Promise((resolve, reject) => {
+				const msg_id = Date.now().toString();
+				const key = `${conn_id}:${msg_id}`;
+				clients.set(conn_id, name);
+
+				// Start timeout/interval and keep its handle so we can clear it on response
+				let intervals = 0;
+				const timer = setInterval(() => {
+					intervals++;
+					if (intervals >= MAX_INTERVALS) {
+						clearInterval(timer);
+						if (pendingResponses.has(key)) {
+							reject('Timeout after max intervals');
+							pendingResponses.delete(key);
+						}
+					}
+				}, TIMEOUT);
+
+				// Store handlers and timer so onMessage can resolve/reject and clear the timer
+				pendingResponses.set(key, { resolve, reject, timer });
+
+				ws.sendToConnection(conn_id, JSON.stringify({
+					action: 'agent_query',
+					id: msg_id,
+					content: params.query
+				}));
+			}).then(response => (response));
+		})
+}
+
+// Provide a toolset based on websocket calls
+class AgentServer {
+	#debug = false;
+	#port = 8000;
+	#name = '';
+	#description = '';
+	/** @type {Prompt} */
+	#prompt
+	/** @type {Session} */
+	#session
+	/** @type {AuthFunction} */
+	#auth = async (conn) => {
+		return true;
+	}
+	/**
+	* @param {AgentServerOptions} options
+	*/
+	constructor(options) {
+		if (options.port) {
+			if (options.port < 1024) {
+				throw new Error('Port must be higher then 1024');
+			}
+			this.#port = options.port;
+		}
+		if (options.auth) {
+			this.#auth = options.auth;
+		}
+		this.#name = options.name;
+		this.#description = options.description;
+		this.#session = options.session;
+		this.#prompt = options.prompt;
+		const events = Object.keys(this.#prompt.EVENTS);
+		events.forEach((evt) => {
+			this.#prompt.on(evt, (_msg) => {
+				console.log(evt);
+			});
+		});
+		this.#debug = options.debug;
+		// start 
+		(async () => {
+			await this._start();
+		})();
+	}
+	/**
+	* @private
+	* Returns a Dynamic Toolset
+	* With registered WS clients as toolcalls
+	* A deamon start on local host 127.0.0.1, always
+	* @returns {Promise<void>}
+	*/
+	async _start() {
+		const name = this.#name;
+		const description = this.#description;
+		const port = this.#port;
+		const DEBUG = this.#debug;
+		const API = {
+			/**
+			* @param {Client} client
+			*/
+			index: async (client) => {
+				await client.serve(200, { name, description });
+			}
+		};
+		ws = new WebSocketServer({
+			verbose: this.#debug,
+			onMessage: async (conn, msg) => {
+				if (!msg.action || !ACTIONS.includes(msg.action)) {
+					console.log('Unkown action: ' + msg.action);
+					deleteClient(this.#prompt.toolset, conn.id)
+					ws.closeConnection(conn.id);
+					return;
+				}
+				if (msg.action === 'agent_introduction') {
+					// Register Toolset Agent
+					// CLient is added as a Toolset function call
+					const name = msg.name;
+					const content = (typeof msg.content === 'string') ? msg.content : JSON.stringify(msg.content);
+					if (!content) {
+						deleteClient(this.#prompt.toolset, conn.id)
+						ws.closeConnection(conn.id);
+						return;
+					}
+					addClient(this.#prompt.toolset, conn.id, name, content);
+					return;
+				}
+				if (msg.action === 'agent_response') {
+					const key = `${conn.id}:${msg.id}`; // Assume client includes original 'id' in response
+					const pending = pendingResponses.get(key);
+					if (pending) {
+            try { clearInterval(pending.timer); } catch {}
+            pending.resolve(msg.content);
+						pendingResponses.delete(key);
+					}
+					return;
+				}
+				if (msg.action === 'agent_error') {
+					const key = `${conn.id}:${msg.id}`; // Assume client includes original 'id' in response
+					const pending = pendingResponses.get(key);
+					if (pending) {
+            try { clearInterval(pending.timer); } catch {}
+            pending.reject(msg.content);
+						pendingResponses.delete(key);
+					}
+					return;
+				}
+				// -------- USER INTERACTION --------------------------------------------------------
+				// CLI / WS interaction to MAIN
+				if (msg.action === 'user_request') {
+					const action = `user_reponse`;
+					const id = msg.id;
+					if (!msg.content || msg.content.trim() === '') {
+						// Empty message, empty reponse
+						ws.sendToConnection(conn.id, JSON.stringify({
+							action: 'user_response',
+							id,
+							content: ''
+						}));
+						return;
+					}
+					// Bind to THIS prompt
+					console.log(`user_request:>>\n${msg.content}\n`);
+					const content = await this.#prompt.call(msg.content);
+					ws.sendToConnection(conn.id, JSON.stringify({
+						action: 'server_response',
+						id,
+						content
+					}));
+					console.log(`server_reponse:>>\n${content}\n`);
+				}
+				if (msg.action === 'user_reset') {
+					const id = msg.id;
+					this.#prompt.reset();
+					ws.sendToConnection(conn.id, JSON.stringify({
+						action: 'server_reset',
+						id,
+						content: 'ok'
+					}));
+				}
+				if (msg.action === 'user_sessionlist') {
+					const id = msg.id;
+					const sess = this.#session.sessionList().reverse();
+					sess.push('NONE');
+					ws.sendToConnection(conn.id, JSON.stringify({
+						action: 'server_sessionlist',
+						id,
+						content: sess
+					}));
+				}
+
+				if (msg.action === 'user_loadsession') {
+					const id = msg.id;
+					const selected = msg.content;
+					const messages = [];
+					const list = this.#session.set(selected);
+					list.forEach((msg) => {
+						if (!msg.sticky) {
+							if (['user', 'assistant', 'reasoning', 'log'].includes(msg.role)) {
+								if (msg.role === 'assistant' && msg.content[0].type === 'function_request') {
+
+								} else {
+									const content = this.#prompt.contentToString(msg.content);
+									messages.push({ role: msg.role, content });
+								}
+							}
+						}
+					});
+					ws.sendToConnection(conn.id, JSON.stringify({
+						action: 'server_sessionloaded',
+						id,
+						content: messages
+					}));
+				}
+				if (msg.action === 'user_info') {
+					const id = msg.id;
+					const sessionInfo = this.#session.info();
+					const promptInfo = this.#prompt.info();
+					const info = `\nSESSION\n${sessionInfo}\nPROMPT\n${promptInfo}\nSERVER\nName: ${this.#name}\nDescription: ${this.#description}`;
+					ws.sendToConnection(conn.id, JSON.stringify({
+						action: 'server_info',
+						id,
+						content: info
+					}));
+				}
+			},
+			onConnection: async (conn) => {
+				return this.#auth(conn);
+			},
+			onClose: async (conn, reason) => {
+				deleteClient(this.#prompt.toolset, conn.id);
+
+			},
+			onError: async (conn, error) => {
+				// console.error(error);
+				deleteClient(this.#prompt.toolset, conn.id);
+				ws.closeConnection(conn.id);
+			}
+		});
+		await server.create('v1', { port, host: '127.0.0.1', ws, strict: DEBUG, verbose: DEBUG }, API);
+		console.log(`ws running on port: ${port}`);
+	}
+	/**
+	* Send a reset messages to all clients
+	* reset will start a new session
+	*/
+	resetAll() {
+		ws.broadcast({ action: 'reset' });
+	}
+}
+
+export default AgentServer;