@j-o-r/hello-dave 0.0.0

package/lib/Prompt.js

@@ -0,0 +1,728 @@
+/**
+ * Create a uniform prompt/message AI format
+ * An attempt to make working with messages/conversations easier and interchangeable
+ * across AI platforms/LLMs.
+ * The initial format/structure is inspired by the OPENAI messages format (but not compatible)
+ */
+import tokens from 'gpt-3-encoder';
+import { EventEmitter } from 'node:events';
+import { pruneResolvedToolIOByCallIdExceptLast as pruneResolvedToolIOByCallIdExceptLastHelper } from './promptHelpers.js';
+
+/**
+* @typedef {import('./API/openai.com/reponses/text.js').request} OARequest
+* @typedef {import('./API/x.ai/text.js').request} XRequest
+* @typedef {import('./API/anthropic.com/text.js').request} ANTHRequest
+* 
+* @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 {import('./ToolSet.js').default} ToolSet
+* @typedef {OARequest|XRequest|ANTHRequest} request - The AI model to use for chat functionality.
+* @typedef {OAOptions|XOptions|ANTHOptions} options - Model options
+*/
+
+/** 
+* @typedef {'system'|'assistant'|'user'|'tool'|'log'|'reasoning'} Roles
+*/
+/**
+* @typedef {Object} Record
+* @property {string} id - remote request id or generated requestId
+* @property {string} isoDate - Date in ISO string format
+* @property {number} duration - Execution time in MS of the model / method
+* @property {string} environment - Execution context endpoint_name / server_name / interpreter_name
+* @property {string} model - LLM model, method , funtion name
+* @property {number} tokensIn - Number of tokens to process
+* @property {number} tokensOut - Number of tokens in the response
+*/
+/**
+* @typedef {Object} TextMessage
+* @property {string} type="text" - The type of the message, should be "text".
+* @property {string} text - The content of the text message.
+*/
+/**
+* @typedef {Object} ImageMessage
+* @property {string} type="image_url" - The type of the message, should be "image_url".
+* @property {string} url - URL or "data:image/png;base64,{base64_image}"
+*/
+/**
+* @typedef {Object} AudioMessage
+* @property {string} type="url" - The type of the message, should be "image_url".
+* @property {string} url - URL or "data:image/png;base64,{base64_image}"
+*/
+/**
+* @typedef {Object} FunctionRequest
+* The `PRMessagerole.role` must be 'assistant'
+* @property {'function_request'} type - The type of the message, should be "function_request". 
+* @property {object} function_request - Function object with properties
+* @property {string} function_request.name - function "name" to call
+* @property {string} function_request.id - The given ID of the function call
+* @property {string} function_request.call_id - function call id
+* @property {string} function_request.parameters - JSON string of the parameters e.g. "{\"unit\":\"celsius\"}" 
+*/
+/**
+* @typedef {Object} FunctionResponse
+* The `PRMessage.role` must 'tool'
+* @property {'function_response'} type  - The type of the message, should be "function_response". 
+* @property {object} function_response - Function object with properties
+* @property {string} function_response.name - function "name" called
+* @property {string} function_response.id - The given ID of the function call
+* @property {string} function_response.call_id - the function call id
+* @property {string} function_response.response - JSON string of the reponse e.g. "{\"temperature\":24}" 
+*/
+
+/**
+* @typedef {TextMessage|ImageMessage|AudioMessage|FunctionRequest|FunctionResponse} Content
+*/
+/**
+* @typedef {object} Message
+* @property {Roles} role -  Message role
+* @property {Content[]} content -  
+* @property {string} [name] - optional author name
+* @property {boolean} [sticky] - This message object is part of the base prompt (reuse after reset) and is not truncated
+* @property {number} [ts] - A timestamp in MS for reconstruction truncated prompts (for creating large context embeddings)
+*/
+const MESSAGE_ROLES = {
+	SYSTEM: 'system',       // system prompt
+	ASSISTANT: 'assistant', // assistent response
+	REASONING: 'reasoning', // assistant reasoning: https://docs.x.ai/docs/guides/reasoning
+	USER: 'user',           // user input
+	TOOL: 'tool',           // function calls
+	LOG: 'log'              // Additional log info
+}
+const MESSAGE_TYPES = {
+	TEXT: 'text',
+	IMAGE_URL: 'image_url',
+	AUDIO_URL: 'audio_url',
+	FUNCTION_REQUEST: 'function_request',
+	FUNCTION_RESPONSE: 'function_response'
+};
+
+const EVENTS = {
+	start: 'start',                 // starts a request
+	retrigger: 'retrigger',         // retriggers start AFTER an import
+	finished: 'finished',           // finished requests
+	message: 'message',             // received a message
+	record: 'record',               // received a record
+	truncated: 'truncated',         // Prompt messages are truncated
+	reset: 'reset',                 // Prompt reset
+	ready: 'ready',                 // Call or trigger has finished
+	error: 'error',                 // An error of some kind
+	warning: 'warning',             // An warning of some kind
+	tool_request: 'tool_request',   // Start a function call
+	tool_response: 'tool_response', // Exit a function call
+	tool_error: 'tool_error',        // Error in function call
+	http_request: 'http_request',   // Start a function call
+	http_response: 'http_response', // Exit a function call
+}
+/**
+* Converts an array of text messages to a string.
+* @param {Content[]} content - An array of messages.
+* @returns {string} - The concatenated text messages.
+*/
+const messagesToString = (content) => {
+	let result = '';
+	content.forEach((mesg) => {
+		if (mesg.type === MESSAGE_TYPES.TEXT) {
+			result += mesg[MESSAGE_TYPES.TEXT] + '\n';
+		}
+		if (mesg.type === MESSAGE_TYPES.IMAGE_URL) {
+			result += mesg.url + '\n';
+		}
+		if (mesg.type === MESSAGE_TYPES.AUDIO_URL) {
+			result += mesg.url + '\n';
+		}
+		if (mesg.type === MESSAGE_TYPES.FUNCTION_REQUEST) {
+			result += `function_request: ${JSON.stringify(mesg[MESSAGE_TYPES.FUNCTION_REQUEST])}\n`;
+		}
+		if (mesg.type === MESSAGE_TYPES.FUNCTION_RESPONSE) {
+			result += `function_response: ${JSON.stringify(mesg[MESSAGE_TYPES.FUNCTION_RESPONSE])}\n`;
+		}
+	});
+	return result.trim();
+};
+
+/**
+* Check if a record is valid
+* @param {Record} record
+* @throws {Error} If the record is invalid.
+*/
+const isValidRecord = (record) => {
+	if (
+		typeof record['id'] === 'string' &&
+		record.id.length > 0 &&
+		typeof record['isoDate'] === 'string' &&
+		record.isoDate.length > 9 &&
+		typeof record['environment'] === 'string' &&
+		record.environment.length > 0 &&
+		typeof record['model'] === 'string' &&
+		record.model.length > 0 &&
+		typeof record['duration'] === 'number' &&
+		typeof record['tokensIn'] === 'number' &&
+		typeof record['tokensOut'] === 'number'
+	) {
+		return;
+	}
+	throw new Error('Invalid record');
+}
+
+/**
+* Checks if a message is valid based on its role and type.
+* @param {Roles} role - The role of the message (e.g., 'system', 'assistant', 'user', 'tool').
+* @param {Content} msg - The message object.
+* @throws {Error} If the message is invalid.
+*/
+const isValidMessage = (role, msg) => {
+	if (!Object.values(MESSAGE_ROLES).includes(role)) {
+		throw new Error('Unkown role detected');
+	}
+	switch (msg.type) {
+		case MESSAGE_TYPES.TEXT:
+			if (!isValidTextMessage(msg)) throw new Error('Invalid text message');
+			if (role === 'tool') throw new Error('Invalid role for text message: role tool is not valid');
+			break;
+		case MESSAGE_TYPES.IMAGE_URL:
+			if (!isValidUrlMessage(msg)) throw new Error('Invalid image_url message');
+			if (role !== 'user') throw new Error('Invalid role for image_url: use user');
+			break;
+		case MESSAGE_TYPES.AUDIO_URL:
+			if (!isValidUrlMessage(msg)) throw new Error('Invalid audio_url message');
+			if (role !== 'user') throw new Error('Invalid role for audio_url: use user');
+			break;
+		case MESSAGE_TYPES.FUNCTION_REQUEST:
+			if (!isValidFunctionRequest(msg)) throw new Error('Invalid function_request message');
+			if (role !== 'assistant') throw new Error('Invalid role for function_request: use assistant');
+			break;
+		case MESSAGE_TYPES.FUNCTION_RESPONSE:
+			if (!isValidFunctionResponse(msg)) throw new Error('Invalid function_reponse message');
+			if (role !== 'tool') throw new Error('Invalid role for function_response: use tool');
+			break;
+		default:
+			throw new Error('Invalid message type detected');
+	}
+}
+
+/**
+* Checks if a URL or data URL is valid.
+* @param {string} str - The URL or data URL string.
+* @returns {boolean} - True if the URL or data URL is valid, false otherwise.
+*/
+const isValidUrlOrDataUrl = (str) => {
+	try {
+		// Check if it's a valid URL
+		new URL(str);
+		return true;
+	} catch (_) {
+		// Check if it's a valid data URL
+		const dataUrlPattern = /^data:[a-z]+\/[a-z0-9-+.]+;base64,[a-z0-9+/]+={0,2}$/i;
+		return dataUrlPattern.test(str);
+	}
+}
+/**
+* Checks if this a text message
+* However, the text may be empty, this can happen with empty assistant reponses
+* @param {Content} msg - The object to check.
+* @returns {boolean} - True if valid, false otherwise.
+*/
+const isValidTextMessage = (msg) => {
+	if (
+		MESSAGE_TYPES.TEXT === msg['type'] &&
+		typeof msg['text'] === 'string'
+	) {
+		return true
+	}
+	return false
+}
+
+/**
+* Checks if this a img_url message
+* @param {Content} msg - The object to check.
+* @returns {boolean} - True if valid, false otherwise.
+*/
+const isValidUrlMessage = (msg) => {
+	if (
+		[MESSAGE_TYPES.IMAGE_URL, MESSAGE_TYPES.AUDIO_URL].includes(msg['type']) &&
+		isValidUrlOrDataUrl(msg['url'])
+	) {
+		return true
+	}
+	return false
+}
+
+/**
+* Checks if this a function_request message
+* @param {Content} msg - The object to check.
+* @returns {boolean} - True if valid, false otherwise.
+*/
+const isValidFunctionRequest = (msg) => {
+	if (
+		MESSAGE_TYPES.FUNCTION_REQUEST === msg['type'] &&
+		typeof msg['function_request'] === 'object' &&
+		typeof msg['function_request']['name'] === 'string' &&
+		typeof msg['function_request']['id'] === 'string' &&
+		typeof msg['function_request']['parameters'] === 'string' &&
+		msg['function_request']['name'].trim().length > 0 &&
+		msg['function_request']['id'].trim().length > 0
+	) {
+		return true
+	}
+	return false
+}
+
+/**
+* Checks if this a function_response message
+* @param {Content} msg - The object to check.
+* @returns {boolean} - True if valid, false otherwise.
+*/
+const isValidFunctionResponse = (msg) => {
+	if (
+		MESSAGE_TYPES.FUNCTION_RESPONSE === msg['type'] &&
+		typeof msg['function_response'] === 'object' &&
+		typeof msg['function_response']['name'] === 'string' &&
+		typeof msg['function_response']['id'] === 'string' &&
+		typeof msg['function_response']['response'] === 'string' &&
+		msg['function_response']['name'].trim().length > 0 &&
+		msg['function_response']['id'].trim().length > 0
+	) {
+		return true
+	}
+	return false
+}
+/**
+* 
+* @fires Prompt#add
+* Event: message added
+*
+* @event Prompt#add
+* @type {Message}
+*/
+class Prompt extends EventEmitter {
+	#tokenCount = 0;
+	/** Max prompt size in tokens to post */
+	#contextWindow = 0;
+	/** @type {Array<Message>} */
+	#messages = [];
+	#adapter = {
+		/** @type {request} */
+		request: async () => {
+			throw new Error('Adapapter not set');
+		},
+		/** @type {ToolSet|void} */
+		toolset: null,
+		/** @type {options|void} */
+		options: null
+	}
+	/**
+	* push a message to the messages array
+	* @param {Message} msg
+	* @fires {Prompt#message} 
+	*/
+	#add(msg) {
+		msg.ts = new Date().getTime();
+		this.#messages.push(msg);
+		this.emit(EVENTS.message, msg);
+	}
+
+	/**
+	* Basic check for the order of messages.
+	* @param {Roles} role - The role of the message.
+	* @param {boolean} [sticky] - Whether the message is part of the base prompt.
+	* @throws {Error} If the message order is invalid.
+	*/
+	#basicMessageOrderCheck(role, sticky) {
+		if (!Object.values(MESSAGE_ROLES).includes(role)) {
+			throw new Error('Unknown role detected');
+		}
+		if (role === MESSAGE_ROLES.SYSTEM && !sticky) {
+			throw new Error('System prompt needs to be sticky');
+		}
+		if (role === MESSAGE_ROLES.SYSTEM && this.length > 0) {
+			throw new Error('System prompt needs to be the first message');
+		}
+		if (this.length > 0 && sticky) {
+			if (this.#messages[this.length - 1].sticky === false) {
+				throw new Error('Sticky messages can only be added after other sticky messages');
+			}
+		}
+	}
+	/**
+	* Constructs a new Prompt instance.
+	* If contextWindow = 0 (defaut) the prompt will have no context building up (ONE_SHOT)
+	* @param {number} [contextWindow] - The max size of a total prompt in tokens. (context)
+	*/
+	constructor(contextWindow) {
+		super();
+		if (typeof contextWindow === 'number') {
+			this.#contextWindow = contextWindow;
+		}
+		this.EVENTS = Object.freeze(EVENTS);
+	}
+	/**
+	* @param {request} handler
+	* @param {ToolSet} toolset
+	* @param {options} options
+	*/
+	setAdaptor(handler, toolset, options) {
+		this.#adapter.request = handler
+		this.#adapter.toolset = toolset
+		this.#adapter.options = options
+	}
+	/**
+	* Get the names of the available funtion calls
+	* @returns {string[]}
+	*/
+	toolsetFunctions() {
+		if (!this.#adapter.toolset) return [];
+		return this.#adapter.toolset.list().map(t => t.name);
+	}
+	/**
+	* @returns {ToolSet|void}
+	*/
+	get toolset() {
+		return this.#adapter.toolset;
+	}
+
+	/**
+	* Start a requests 
+	* @param {string|Content} content
+	* @returns {Promise<string>} 
+	*/
+	async call(content) {
+		if (typeof content === 'string') {
+			if (content.trim() === '') {
+				throw 'Input is empty';
+			}
+			this.add('user', content, false);
+		} else if (Array.isArray(content)) {
+			this.addMultiModal('user', content)
+		} else {
+			throw 'Not a valid input';
+		}
+		this.emit(EVENTS.start, true);
+		// @ts-ignore
+		const msg = await this.#adapter.request(this, this.#adapter.toolset, this.#adapter.options);
+		if (this.#tokenCount >= this.#contextWindow) {
+			this.truncate();
+		}
+		this.emit(EVENTS.finished, true);
+		return this.contentToString(msg.content)
+	}
+	/**
+	* Trigger a request when the last added message is a user or tool message 
+	* Exit on error
+	*/
+	async triggerRequest() {
+		if (this.#adapter.toolset) {
+			// See if we need to execute something  first
+			await this.#adapter.toolset.execute(this);
+		}
+		const last = this.getLastMessage();
+		if (!last) return;
+		if (last.role === 'tool' || last.role === 'user') {
+			this.emit(EVENTS.retrigger, true);
+			// @ts-ignore
+			await this.#adapter.request(this, this.#adapter.toolset, this.#adapter.options)
+		}
+		if (this.#tokenCount >= this.#contextWindow) {
+			this.truncate();
+		}
+		this.emit(EVENTS.finished, true);
+	}
+	/**
+	* Get the maximum token length for this prompt
+	* @returns {number}
+	*/
+	get contextLength() {
+		return this.#contextWindow;
+	}
+	/**
+	* Returns a copy of the messages array.
+	* @returns {Message[]} - A copy of the messages array.
+	*/
+	get messages() {
+		return JSON.parse(JSON.stringify(this.#messages));
+	}
+
+	/**
+	* Imports messages.
+	* Bypasses the event emitter
+	* @param {Message[]} messages
+	* @throws {Error} If the input string is invalid.
+	*/
+	set messages(messages) {
+		// Copy 
+		messages = JSON.parse(JSON.stringify(messages));
+		messages.forEach((ob) => {
+			if (typeof ob.sticky !== 'boolean') {
+				throw new Error(`Missing 'sticky' property`);
+			}
+			if (typeof ob.role !== 'string') {
+				throw new Error(`Missing 'role' property`);
+			}
+			if (Array.isArray(ob.content) === false) {
+				throw new Error(`Missing 'content' property`);
+			}
+			const role = ob.role;
+			const list = ob.content;
+			list.forEach((msg) => {
+				isValidMessage(role, msg);
+			});
+		});
+		// Refresh token count
+		this.#tokenCount = 0;
+		this.#messages = messages;
+	}
+	/**
+	* Return the most recent, the LAST message added
+	* @returns {Message|void} 
+	*/
+	getLastMessage() {
+		if (this.#messages.length > 0) {
+			return this.#messages[this.length - 1];
+		}
+	}
+	/**
+	* Return the readable content (type == text)
+	* @param {Content[]} content
+	* @return {string}
+	*/
+	contentToString(content) {
+		return messagesToString(content);
+	}
+	/**
+	* Count the number of tokens on a given string
+	* Or the recorded tokencount of the last roundtrip
+	* @param {string} [str] - the string to count
+	* @param returns {number}
+	*/
+	countTokens(str) {
+		if (str && str !== '') {
+			return tokens.encode(str).length;
+		}
+		return this.#tokenCount;
+	}
+
+
+	/**
+	* reduce the prompt length to fit in the contextWindow
+	* or simply reset when there is no contextWindow
+	* @returns {boolean} true when the prompt has been altered/reduced
+	*/
+	truncate() {
+		const length = this.length;
+		if (length === 0) {
+			return false;
+		}
+		// just reset when there is no room for context 
+		if (this.#contextWindow === 0) {
+			this.reset();
+			this.emit(EVENTS.truncated, EVENTS.truncated)
+			return (length !== this.length);
+		}
+		pruneResolvedToolIOByCallIdExceptLastHelper(this.#messages, 'lastTurn');
+		let totalTokens = 0;
+		let messagesToRemove = [];
+		let block = false;
+		let blockScope = [];
+		let blockTokens = 0;
+
+		for (let i = 0; i < this.#messages.length; i++) {
+			const message = this.#messages[i];
+			if (message.sticky) {
+				totalTokens += this.countTokens(messagesToString(message.content));
+			} else {
+				break;
+			}
+		}
+		// Count backwards and start deleting when a block takes to much space
+		for (let i = this.#messages.length - 1; i >= 0; i--) {
+			const message = this.#messages[i];
+			if (!message.sticky) {
+				// a block starts with a user message
+				// ends with an assistant message
+				// in reverse
+				if (message.role === MESSAGE_ROLES.ASSISTANT) {
+					// start record
+					block = true;
+				} else if (message.role === MESSAGE_ROLES.USER) {
+					// end record
+					// finish it of
+					if (block === true) {
+						blockScope.push(i);
+						blockTokens += this.countTokens(messagesToString(message.content));
+						totalTokens += blockTokens;
+						if (totalTokens > this.#contextWindow) {
+							messagesToRemove = [...messagesToRemove, ...blockScope];
+						};
+						blockTokens = 0;
+						blockScope = [];
+					}
+					block = false;
+				}
+				if (block) {
+					blockScope.push(i);
+					blockTokens += this.countTokens(messagesToString(message.content));
+				}
+			}
+		}
+		messagesToRemove.forEach((index) => {
+			this.#messages.splice(index, 1);
+		});
+		if (length !== this.length) this.emit(EVENTS.truncated, EVENTS.truncated);
+		return (length !== this.length);
+	}
+	/**
+	* Gets the length of the messages array.
+	* @returns {number} - The length of the messages array.
+	*/
+	get length() {
+		return this.#messages.length;
+	}
+
+	/**
+	* Gets the system prompt from the messages.
+	* @returns {string} - The system prompt.
+	* @throws {Error} If no system prompt is available.
+	*/
+	get system_prompt() {
+		if (!this.hasSystemprompt) {
+			throw new Error('No system prompt available');
+		}
+		const sys = this.#messages[0];
+		return messagesToString(sys.content);
+	}
+
+	/**
+	* Checks if a system prompt is available.
+	* @returns {boolean} - True if a system prompt is available, false otherwise.
+	*/
+	get hasSystemprompt() {
+		if (this.#messages.length === 0) {
+			return false;
+		}
+		if (this.#messages[0].role === MESSAGE_ROLES.SYSTEM) {
+			const test = messagesToString(this.#messages[0].content);
+			if (test.trim().length > 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	* Adds a text message to the messages array.
+	* @param {Roles} role - The role of the message.
+	* @param {string} message - The text message.
+	* @param {boolean} [sticky] - Whether the message is part of the base prompt.
+	* @fires Prompt#message
+	* @throws {Error} If the message order is invalid or the message is invalid.
+	*/
+	add(role, message, sticky = false) {
+		const content = [];
+		const txt = {
+			type: 'text',
+			text: message
+		};
+		content.push(txt);
+		/**
+		* @event Prompt#message
+		* @type {Message}
+		*/
+		this.addMultiModal(role, content, sticky);
+	}
+
+	/**
+	* Adds a multi-modal message to the messages array.
+	* @param {Roles} role - The role of the message.
+	* @param {Content[]} messages - The actual messages with multi-modal content.
+	* @param {boolean} [sticky] - Whether the message is part of the base prompt.
+	* @fires Prompt#add
+	* @throws {Error} If the message order is invalid or the messages are invalid.
+	*/
+	addMultiModal(role, messages, sticky = false) {
+		this.#basicMessageOrderCheck(role, sticky);
+		const content = [];
+		messages.forEach((msg) => {
+			isValidMessage(role, msg);
+			content.push(msg);
+		});
+		if (content.length === 0) {
+			throw new Error('No messages found');
+		}
+		/**
+		* @event Prompt#add
+		* @type {Message}
+		*/
+		this.#add({ role, content, sticky });
+	}
+
+	/**
+	* Removes all non-sticky messages and returns them
+	* Keeps the 'base' (sticky) prompt/messages.
+	* @returns {Message[]} 
+	*/
+	reset() {
+		this.#tokenCount = 0;
+		const systemArray = this.#messages.filter(item => item.sticky === true);
+		const conversationArray = this.#messages.filter(item => item.sticky === false);
+		this.#messages = systemArray;
+		this.emit(EVENTS.reset, EVENTS.reset);
+		return conversationArray;
+	}
+
+	/**
+	* Register a record from the adapter
+	* @param {Record} record - Records for billing and optimizing
+	* @throws {Error} If the record is invalid.
+	*/
+	addRecord(record) {
+		isValidRecord(record);
+		this.#tokenCount = record.tokensIn + record.tokensOut
+		this.emit(EVENTS.record, record);
+		if (this.#tokenCount >= this.#contextWindow) {
+			this.emit(EVENTS.warning, `The number of tokens: ${this.#tokenCount} is exceeding the contextWindow: ${this.#contextWindow}`);
+			// Need to truncate
+			// 1. delete all satisfied function requests
+			// 2. run truncate
+		}
+	}
+
+	/**
+	* Add a list of records (with multiple prompts to maintain a full history of events)
+	* @param {Record[]} records - Records for billing and optimizing
+	* @throws {Error} If the record is invalid.
+	*/
+	addRecords(records) {
+		records.forEach((record) => {
+			this.addRecord(record)
+		})
+	}
+	/**
+	* Template record 
+	* @returns {Record}
+	*/
+	templateRecord() {
+		const record = {
+			id: '',
+			isoDate: '',
+			duration: 0,
+			model: '',
+			environment: '',
+			tokensIn: 0,
+			tokensOut: 0
+		}
+		return record
+	}
+	/**
+	* Gather metrics as info
+	*/
+	info() {
+		const cwd = process.cwd();
+		const tools = this.toolsetFunctions().join(', ');
+		const context = this.contextLength;
+		const tokens = this.countTokens();
+		return `Cwd: ${cwd}\nTools: ${tools}\nMax context: ${context}\nUsed Tokens: ${tokens}`
+	}
+
+}
+export default Prompt;