@rws-framework/ai-tools 1.0.5 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/ai-tools",
   "private": false,
-  "version": "1.0.5",
+  "version": "2.0.0",
   "description": "",
   "main": "src/index.ts",
   "scripts": {},

package/src/index.ts

@@ -1,6 +1,7 @@
 
-import RWSPrompt, { ILLMChunk, IRWSPromptRequestExecutor, IRWSSinglePromptRequestExecutor, IRWSPromptStreamExecutor, IChainCallOutput, IRWSPromptJSON, ChainStreamType } from '@rws-framework/ai-tools/src/models/prompts/_prompt';
-import RWSConvo, { IConvoDebugXMLData, IEmbeddingsHandler, ISplitterParams } from './models/convo/ConvoLoader';
+import RWSPrompt, { IChainCallOutput } from '@rws-framework/ai-tools/src/models/prompts/_prompt';
+import { ILLMChunk, IRWSPromptRequestExecutor, IRWSSinglePromptRequestExecutor, IRWSPromptStreamExecutor, IRWSPromptJSON, ChainStreamType, IAIRequestOptions, IAITool, IAIToolSchema, IAIToolParameter, IToolCall, ToolHandler } from './types/IPrompt';
+import { EmbedLoader as RWSEmbed, IConvoDebugXMLData, IEmbeddingsHandler, ISplitterParams } from './models/convo/EmbedLoader';
 import RWSVectorStore from './models/convo/VectorStore';
 import { VectorStoreService } from './services/VectorStoreService';
 import { IContextToken } from './types/IContextToken';
@@ -10,7 +11,7 @@ export {
     IAiCfg,
     VectorStoreService,
     RWSVectorStore,
-    RWSConvo,
+    RWSEmbed,
     RWSPrompt,
     ILLMChunk,
     IRWSPromptRequestExecutor,
@@ -22,5 +23,11 @@ export {
     IConvoDebugXMLData,
     IEmbeddingsHandler,
     ISplitterParams,
-    IContextToken
-};
+    IContextToken,
+    IAIRequestOptions,
+    IAITool,
+    IAIToolSchema,
+    IAIToolParameter,
+    IToolCall,
+    ToolHandler
+};

package/src/models/convo/{ConvoLoader.ts → EmbedLoader.ts}

@@ -2,9 +2,10 @@ import 'reflect-metadata';
 
 import { ConsoleService, RWSConfigService, RWSErrorCodes} from '@rws-framework/server';
 import { InjectServices } from '@rws-framework/server/src/services/_inject';
-import RWSPrompt, { IRWSPromptJSON, ILLMChunk } from '../../models/prompts/_prompt';
+import RWSPrompt from '../prompts/_prompt';
+import { IRWSPromptJSON, ILLMChunk } from '../../types/IPrompt';
 import {VectorStoreService} from '../../services/VectorStoreService';
-import RWSVectorStore, { VectorDocType } from '../../models/convo/VectorStore';
+import RWSVectorStore, { VectorDocType } from './VectorStore';
 
 import { Document } from '@langchain/core/documents';
 import { UnstructuredLoader } from '@langchain/community/document_loaders/fs/unstructured';
@@ -66,15 +67,12 @@ interface IEmbeddingsHandler<T extends object> {
 type LLMType = BaseLanguageModelInterface | Runnable<BaseLanguageModelInput, string> | Runnable<BaseLanguageModelInput, BaseMessage>;
 
 @InjectServices([VectorStoreService])
-class ConvoLoader<LLMChat extends BaseChatModel> {
+class EmbedLoader<LLMChat extends BaseChatModel> {
     private loader: UnstructuredLoader;
-    // private docSplitter: RecursiveCharacterTextSplitter;    
-
     private embeddings: IEmbeddingsHandler<any>;
 
     private docs: Document[] = [];
     private _initiated = false;
-    private store: RWSVectorStore;
     private convo_id: string;        
     private llmChat: LLMChat;
     private chatConstructor: new (config: any) => LLMChat;
@@ -97,7 +95,7 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
     ) {
         this.embeddings = embeddings;
         if(convoId === null) {
-            this.convo_id = ConvoLoader.uuid();
+            this.convo_id = EmbedLoader.uuid();
         } else {
             this.convo_id = convoId;
         }                        
@@ -108,17 +106,40 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
     static uuid(): string
     {
         return uuid();
+    }    
+
+    getId(): string {
+        return this.convo_id;
+    }
+
+    getDocs(): VectorDocType
+    {
+        return this.docs;
+    }
+
+    isInitiated(): boolean 
+    {
+        return this._initiated;
     }
 
+    getChat(): LLMChat
+    {
+        return this.llmChat;
+    }
+
+    private avgDocLength = (documents: Document[]): number => {
+        return documents.reduce((sum, doc: Document) => sum + doc.pageContent.length, 0) / documents.length;
+    };
 
-    async splitDocs(filePath: string, params: ISplitterParams)
+    async splitDocs(filePath: string, params: ISplitterParams): Promise<RWSVectorStore>
     {
 
         if(!this.embeddings){
             throw new Error('No embeddings provided for ConvoLoader\'s constructor. ConvoLoader.splitDocs aborting...');
         }
 
-        const splitDir = ConvoLoader.debugSplitDir(this.getId());
+        const splitDir = EmbedLoader.debugSplitDir(this.getId());
+        const finalDocs = [];
 
         if(!fs.existsSync(splitDir)){
             console.log(`Split dir ${ConsoleService.color().magentaBright(splitDir)} doesn't exist. Splitting docs...`);
@@ -142,10 +163,9 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
             logConvo(`After the split we have ${splitDocs.length} documents more than the original ${orgDocs.length}.`);
             logConvo(`Average length among ${orgDocs.length} documents (after split) is ${avgCharCountPost} characters.`);
 
-            this.docs = splitDocs;            
-
             let i = 0;
-            this.docs.forEach((doc: Document) => {
+            splitDocs.forEach((doc: Document) => {
+                finalDocs.push(doc);
                 fs.writeFileSync(this.debugSplitFile(i), doc.pageContent);
                 i++;
             });
@@ -154,67 +174,17 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
             
             for(const filePath of splitFiles) {
                 const txt = fs.readFileSync(splitDir + '/' + filePath, 'utf-8');
-                this.docs.push(new Document({ pageContent: txt }));              
+                finalDocs.push(new Document({ pageContent: txt }));              
             }
         }
         
-        this.store = await this.vectorStoreService.createStore(this.docs, await this.embeddings.generateEmbeddings());
-    }
-
-    getId(): string {
-        return this.convo_id;
+        return await this.vectorStoreService.createStore(finalDocs, await this.embeddings.generateEmbeddings());
     }
 
-    getDocs(): VectorDocType
-    {
-        return this.docs;
-    }
-    getStore(): RWSVectorStore
-    {
-        return this.store;
-    }
-
-    isInitiated(): boolean 
-    {
-        return this._initiated;
-    }
-
-    setPrompt(prompt: RWSPrompt): ConvoLoader<LLMChat>
-    {
-        this.thePrompt = prompt;        
-
-        this.llmChat = new this.chatConstructor({
-            streaming: true,
-            region: this.configService.get('aws_bedrock_region'),  
-            credentials: {  
-                accessKeyId: this.configService.get('aws_access_key'),  
-                secretAccessKey: this.configService.get('aws_secret_key'),  
-            },  
-            model: 'anthropic.claude-v2',            
-            maxTokens: prompt.getHyperParameter<number>('max_tokens_to_sample'),
-            temperature: prompt.getHyperParameter<number>('temperature'),
-            modelKwargs: {
-                top_p: prompt.getHyperParameter<number>('top_p'),
-                top_k: prompt.getHyperParameter<number>('top_k'),
-            }
-        });        
-
-        return this;
-    }
-
-    getChat(): LLMChat
-    {
-        return this.llmChat;
-    }
-
-    private avgDocLength = (documents: Document[]): number => {
-        return documents.reduce((sum, doc: Document) => sum + doc.pageContent.length, 0) / documents.length;
-    };
-
-    async similaritySearch(query: string, splitCount: number): Promise<string>
+    async similaritySearch(query: string, splitCount: number, store: RWSVectorStore): Promise<string>
     {
         console.log('Store is ready. Searching for embedds...');            
-        const texts = await this.getStore().getFaiss().similaritySearchWithScore(`${query}`, splitCount);
+        const texts = await store.getFaiss().similaritySearchWithScore(`${query}`, splitCount);
         console.log('Found best parts: ' + texts.length);
         return texts.map(([doc, score]: [any, number]) => `${doc['pageContent']}`).join('\n\n');    
     }
@@ -240,7 +210,7 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
     }
 
 
-    async waitForInit(): Promise<ConvoLoader<LLMChat> | null>
+    async waitForInit(): Promise<EmbedLoader<LLMChat> | null>
     {
         const _self = this;
         return new Promise((resolve, reject)=>{
@@ -262,6 +232,10 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
         });
     }  
 
+    async setPrompt(prompt: RWSPrompt){
+        this.thePrompt = prompt;
+    }
+
     private parseXML(xml: string, callback: (err: Error, result: any) => void): xml2js.Parser
     {
         const parser = new xml2js.Parser();        
@@ -279,11 +253,11 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
     }
     
     public debugConvoFile(){
-        return `${ConvoLoader.debugConvoDir(this.getId())}/conversation.xml`;
+        return `${EmbedLoader.debugConvoDir(this.getId())}/conversation.xml`;
     }    
 
     public debugSplitFile(i: number){
-        return `${ConvoLoader.debugSplitDir(this.getId())}/${i}.splitfile`;
+        return `${EmbedLoader.debugSplitDir(this.getId())}/${i}.splitfile`;
     }    
 
     private initDebugFile(): IConvoDebugXMLOutput
@@ -291,7 +265,7 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
         let xmlContent: string;
         let debugXML: IConvoDebugXMLData = null;
 
-        const convoDir = ConvoLoader.debugConvoDir(this.getId());
+        const convoDir = EmbedLoader.debugConvoDir(this.getId());
 
         if(!fs.existsSync(convoDir)){
             fs.mkdirSync(convoDir, { recursive: true });
@@ -326,5 +300,4 @@ class ConvoLoader<LLMChat extends BaseChatModel> {
 
 }
 
-export default ConvoLoader;
-export { IChainCallOutput, IConvoDebugXMLData, IEmbeddingsHandler, ISplitterParams, IBaseLangchainHyperParams };
+export { EmbedLoader, IChainCallOutput, IConvoDebugXMLData, IEmbeddingsHandler, ISplitterParams, IBaseLangchainHyperParams };

package/src/models/convo/VectorStore.ts

@@ -26,6 +26,11 @@ export default class RWSVectorStore
     {
         return this.faiss;
     }
+
+    getDocs()
+    {
+        return this.docs;
+    }
 }
 
 export {

package/src/models/prompts/_prompt.ts

@@ -1,90 +1,47 @@
 import { Readable } from 'stream';
 import { PromptTemplate } from '@langchain/core/prompts';
-import ConvoLoader, { IChainCallOutput } from '../../models/convo/ConvoLoader';
-import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
-import { IterableReadableStream } from '@langchain/core/utils/stream';
-import { ChainValues } from '@langchain/core/utils/types';
-import { IContextToken } from '../../types/IContextToken';
+import { EmbedLoader, IChainCallOutput } from '../convo/EmbedLoader';
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { IToolCall } from '../../types/IPrompt'
+import { 
+    IPromptSender, 
+    IPromptEnchantment, 
+    IPromptParams, 
+    IPromptHyperParameters, 
+    IRWSPromptRequestExecutor, 
+    IRWSPromptStreamExecutor, 
+    IRWSSinglePromptRequestExecutor, 
+    IRWSPromptJSON, 
+    ChainStreamType, 
+    ILLMChunk,
+    IAITool,
+    IRWSHistoryMessage,
+    InputType,
+    CompoundInput,
+    ToolHandler
+} from '../../types/IPrompt';
+import { IContextToken } from '../../types/IContextToken';
 
-interface IPromptHyperParameters {
-    temperature: number,
-    top_k?: number,
-    top_p?: number,
-    [key: string]: number
-}
-
-interface IRWSHistoryMessage { 
-    content: string, creator: string 
-}
-
-interface ILLMChunk {
-    content: string
-    status: string
- }
-
-interface IPromptParams {
-    hyperParameters?: IPromptHyperParameters;
-    input?: string;
-    modelId: string;
-    modelType: string;
-}
-
-interface IPromptEnchantment {
-    enhancementId: string,
-    enhancementName: string,
-    enhancementParams: any,
-    input: string
-    output: string
-}
-
-type IPromptSender = (prompt: RWSPrompt) => Promise<void>;
-
-interface IRWSPromptRequestExecutor {
-    promptRequest: (prompt: RWSPrompt, contextToken?: IContextToken | null, intruderPrompt?: string | null, debugVars?: any) => Promise<RWSPrompt>
-}
-
-
-interface IRWSSinglePromptRequestExecutor {
-    singlePromptRequest: (prompt: RWSPrompt, contextToken?: IContextToken | null, intruderPrompt?: string | null, ensureJson?: boolean, debugVars?: any) => Promise<RWSPrompt>
-}
-
-
-interface IRWSPromptStreamExecutor {
-    promptStream: (prompt: RWSPrompt, read: (chunk: ILLMChunk) => void, end: () => void, debugVars?: any) => Promise<RWSPrompt>
-}
-
-interface IRWSPromptJSON {
-    input: string;
-    enhancedInput: IPromptEnchantment[];
-    sentInput: string;
-    originalInput: string;
-    output: string;
-    modelId: string;
-    modelType: string;
-    multiTemplate: PromptTemplate;
-    convo: { id: string };
-    hyperParameters: IPromptHyperParameters;
-    created_at: string;
-    var_storage: any;
+type EntryParams = {
+    modelId: string,
+    body: string,
 }
 
-type ChainStreamType = AsyncGenerator<IterableReadableStream<ChainValues>>;
 
 class RWSPrompt {
     public _stream: ChainStreamType;
-    private input: string = '';
+    private input: CompoundInput[] = [];    
     private enhancedInput: IPromptEnchantment[];
-    private sentInput: string = '';
-    private originalInput: string = '';
+    private sentInput: CompoundInput[] = [];
+    private originalInput: CompoundInput[] = [];
     private output: string = '';
     private modelId: string;
     private modelType: string;
     private multiTemplate: PromptTemplate;
-    private convo: ConvoLoader<any>;
+    private embedLoader: EmbedLoader<any>;
     private hyperParameters: IPromptHyperParameters;
     private created_at: Date;
-
+    private toolHandlers: Map<string, ToolHandler> = new Map();
     private varStorage: any = {};
 
     private onStream = (chunk: string) => {
@@ -123,7 +80,7 @@ class RWSPrompt {
     addEnchantment(enchantment: IPromptEnchantment): void
     {
         this.enhancedInput.push(enchantment);
-        this.input = enchantment.input;        
+        this.input.push(enchantment.input);        
     }
 
     getEnchantedInput(): string | null
@@ -136,23 +93,23 @@ class RWSPrompt {
         return this.modelId;
     }
 
-    readSentInput(): string
+    readSentInput(): CompoundInput[]
     {
         return this.sentInput;
     }
 
-    readInput(): string
+    readInput(): CompoundInput[]
     {
         return this.input;
     }
 
     
-    readBaseInput(): string
+    readBaseInput(): CompoundInput[]
     {
         return this.originalInput;
     }    
 
-    setBaseInput(input: string): RWSPrompt
+    setBaseInput(input: CompoundInput[]): RWSPrompt
     {
         this.originalInput = input;
         
@@ -214,16 +171,16 @@ class RWSPrompt {
         return this.multiTemplate;
     }
 
-    setConvo(convo: ConvoLoader<BaseChatModel>): RWSPrompt
+    setEmbedLoader(embedLoader: EmbedLoader<BaseChatModel>): RWSPrompt
     {
-        this.convo = convo.setPrompt(this);        
+        this.embedLoader = embedLoader;        
         
         return this;
     }
 
-    getConvo<T extends BaseChatModel>(): ConvoLoader<T>
+    getEmbedLoader<T extends BaseChatModel>(): EmbedLoader<T>
     {
-        return this.convo;
+        return this.embedLoader;
     }
 
     replacePromptVar(key: string, val: string)
@@ -236,28 +193,28 @@ class RWSPrompt {
         return [this.modelType, this.modelId];
     }
 
-    async requestWith(executor: IRWSPromptRequestExecutor, intruderPrompt: string = null, debugVars: any = {}): Promise<void>
+    async requestWith(executor: IRWSPromptRequestExecutor, intruderPrompt: string = null, debugVars: any = {}, tools?: IAITool[]): Promise<void>
     {
         this.sentInput = this.input;
-        const returnedRWS = await executor.promptRequest(this, null, intruderPrompt, debugVars);
+        const returnedRWS = await executor.promptRequest(this, { intruderPrompt, debugVars, tools });
         this.output = returnedRWS.readOutput();        
     }
 
-    async singleRequestWith(executor: IRWSSinglePromptRequestExecutor, intruderPrompt: string = null, ensureJson: boolean = false): Promise<void>
+    async singleRequestWith(executor: IRWSSinglePromptRequestExecutor, intruderPrompt: string = null, ensureJson: boolean = false, tools?: IAITool[]): Promise<void>
     {        
-        await executor.singlePromptRequest(this, null, intruderPrompt, ensureJson);
+        await executor.singlePromptRequest(this, { intruderPrompt, ensureJson, tools });
         this.sentInput = this.input;
     }
 
-    async streamWith(executor: IRWSPromptStreamExecutor, read: (chunk: ILLMChunk) => void, end: () => void = () => {}, debugVars: any = {}): Promise<RWSPrompt>
+    async streamWith(executor: IRWSPromptStreamExecutor, read: (chunk: ILLMChunk) => void, end: () => void = () => {}, debugVars: any = {}, tools?: IAITool[]): Promise<RWSPrompt>
     {        
         this.sentInput = this.input;
-        return executor.promptStream(this, read, end, debugVars);
+        return executor.promptStream(this, read, end, { debugVars, tools });
     }
 
-    setInput(content: string): RWSPrompt
+    addInput(content: CompoundInput): RWSPrompt
     {
-        this.input = content;
+        this.input.push(content);
         return this;
     }
 
@@ -272,35 +229,6 @@ class RWSPrompt {
         return this;
     } 
 
-    async _oldreadStream(stream: Readable, react: (chunk: string) => void): Promise<void>    
-    {        
-        let first = true;
-        const chunks: string[] = []; // Replace 'any' with the actual type of your chunks
-       
-        for await (const event of stream) {            
-            // Assuming 'event' has a specific structure. Adjust according to actual event structure.
-            if ('chunk' in event && event.chunk.bytes) {
-                const chunk = JSON.parse(Buffer.from(event.chunk.bytes).toString('utf-8'));
-                if(first){
-                    console.log('chunk', chunk);
-                    first = false;
-                }
-
-                react(chunk.completion);
-
-                chunks.push(chunk.completion || chunk.generation ); // Use the actual property of 'chunk' you're interested in
-            } else if (
-                'internalServerException' in event ||
-                'modelStreamErrorException' in event ||
-                'throttlingException' in event ||
-                'validationException' in event
-            ) {
-                console.error(event);
-                break;
-            }            
-        }        
-    }
-
     private async isChainStreamType(source: any): Promise<boolean> {
         if (source && typeof source[Symbol.asyncIterator] === 'function') {
             const asyncIterator = source[Symbol.asyncIterator]();
@@ -319,7 +247,7 @@ class RWSPrompt {
         return false;
     }
 
-    async  readStreamAsText(readableStream: ReadableStream, callback: (txt: string) => void) {
+    async readStreamAsText(readableStream: ReadableStream, callback: (txt: string) => void) {
         const reader = readableStream.getReader();
                 
         let readResult: any;
@@ -346,8 +274,35 @@ class RWSPrompt {
         if(callback){
             callback(messages, prompt);
         }else{
-            this.input = prompt + this.input;
+            this.input =  [{type: 'text', text: prompt}, ...this.input];
+        }
+    }
+
+    registerToolHandlers(toolHandlers: { [key: string]: ToolHandler }){
+        for(const key of Object.keys(toolHandlers)){
+            this.toolHandlers.set(key, toolHandlers[key]);
+        }        
+    }
+
+    async callTools<T = unknown>(tools: IToolCall[]): Promise<T[]>
+    {
+        const results: T[] = [];
+        for(const tool of tools){
+            if(this.toolHandlers.has(tool.name)){
+                const result = await this.callAiTool<T>(tool);
+                if(result){
+                    results.push(result);
+                }                
+            }
         }
+
+        return results;
+    }
+
+    private async callAiTool<T>(tool: IToolCall): Promise<T>
+    {
+        const handler = this.toolHandlers.get(tool.name);
+        return await handler(tool.arguments);
     }
 
     toJSON(): IRWSPromptJSON
@@ -361,8 +316,8 @@ class RWSPrompt {
             modelId: this.modelId,
             modelType: this.modelType,
             multiTemplate: this.multiTemplate,            
-            convo: {
-                id: this.convo.getId()
+            embed: {
+                id: this.embedLoader.getId()
             },
             hyperParameters: this.hyperParameters,
             var_storage: this.varStorage,
@@ -373,16 +328,4 @@ class RWSPrompt {
 
 export default RWSPrompt;
 
-export { 
-    IPromptSender, 
-    IPromptEnchantment, 
-    IPromptParams, 
-    IPromptHyperParameters, 
-    IRWSPromptRequestExecutor, 
-    IRWSPromptStreamExecutor, 
-    IRWSSinglePromptRequestExecutor, 
-    IRWSPromptJSON, 
-    IChainCallOutput, 
-    ChainStreamType, 
-    ILLMChunk 
-};
+export { IChainCallOutput };

package/src/types/IPrompt.ts

@@ -0,0 +1,161 @@
+import { PromptTemplate } from '@langchain/core/prompts';
+import { IterableReadableStream } from '@langchain/core/utils/stream';
+import { ChainValues } from '@langchain/core/utils/types';
+import { IContextToken } from './IContextToken';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+// General tool interfaces for AI models
+interface IAIToolParameterBase {
+  type: string;
+  description?: string;
+  enum?: string[];
+  required?: boolean;
+}
+
+interface IAIToolParameterObject extends IAIToolParameterBase {
+  type: 'object';
+  properties: Record<string, IAIToolParameter>;
+}
+
+interface IAIToolParameterArray extends IAIToolParameterBase {
+  type: 'array';
+  items: IAIToolParameter;
+}
+
+interface IAIToolParameterPrimitive extends IAIToolParameterBase {
+  type: 'string' | 'number' | 'boolean' | 'integer';
+}
+
+type IAIToolParameter = IAIToolParameterObject | IAIToolParameterArray | IAIToolParameterPrimitive;
+
+interface IAIToolSchema {
+  type: 'object';
+  properties: Record<string, IAIToolParameter>;
+  required?: string[];
+}
+
+interface IToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+  }
+
+interface IAITool {
+  name: string;
+  description: string;
+  input_schema: IAIToolSchema;
+}
+
+interface IPromptHyperParameters {
+    temperature: number,
+    top_k?: number,
+    top_p?: number,
+    [key: string]: number
+}
+
+interface IRWSHistoryMessage { 
+    content: string, creator: string 
+}
+
+interface ILLMChunk {
+    content: string
+    status: string
+ }
+
+interface IPromptParams {
+    hyperParameters?: IPromptHyperParameters;
+    input: CompoundInput[];    
+    modelId: string;
+    modelType: string;
+}
+
+type InputType = 'text' | 'image';
+
+interface IPromptEnchantment {
+    enhancementId: string,
+    enhancementName: string,
+    enhancementParams: any,
+    input: CompoundInput
+    output: string
+}
+
+// Forward reference to RWSPrompt to avoid circular dependencies
+type RWSPrompt = import('../models/prompts/_prompt').default;
+
+type IPromptSender = (prompt: RWSPrompt) => Promise<void>;
+
+interface IAIRequestOptions {
+    contextToken?: IContextToken | null, 
+    intruderPrompt?: string | null, 
+    ensureJson?: boolean, 
+    debugVars?: any,
+    tools?: IAITool[]
+}
+
+interface IRWSPromptRequestExecutor {
+    promptRequest: (prompt: RWSPrompt, aiOptions?: IAIRequestOptions) => Promise<RWSPrompt>
+}
+
+interface IRWSSinglePromptRequestExecutor {
+    singlePromptRequest: (prompt: RWSPrompt, aiOptions?: IAIRequestOptions) => Promise<RWSPrompt>
+}
+
+interface IRWSPromptStreamExecutor {
+    promptStream: (prompt: RWSPrompt, read: (chunk: ILLMChunk) => void, end: () => void, aiOptions?: IAIRequestOptions) => Promise<RWSPrompt>
+}
+
+type ToolHandler<T = any> = (...args: any) => Promise<T>;
+
+interface IRWSPromptJSON {
+    input: CompoundInput[];
+    enhancedInput: IPromptEnchantment[];
+    sentInput: CompoundInput[];
+    originalInput: CompoundInput[];
+    output: string;
+    modelId: string;
+    modelType: string;
+    multiTemplate: PromptTemplate;
+    embed?: { id: string };
+    hyperParameters: IPromptHyperParameters;
+    created_at: string;
+    var_storage: any;
+}
+
+type ChainStreamType = AsyncGenerator<IterableReadableStream<ChainValues>>;
+
+interface CompoundInput {
+    type: InputType,
+    text?: string,
+    source?: {
+        type: string,
+        media_type: string,
+        data: string
+    }
+}
+
+export { 
+    IPromptSender, 
+    IPromptEnchantment, 
+    IPromptParams, 
+    IPromptHyperParameters, 
+    IRWSPromptRequestExecutor, 
+    IRWSPromptStreamExecutor, 
+    IRWSSinglePromptRequestExecutor, 
+    IRWSPromptJSON, 
+    ChainStreamType, 
+    ILLMChunk,
+    IAIRequestOptions,
+    IAITool,
+    IAIToolSchema,
+    IAIToolParameter,
+    IAIToolParameterBase,
+    IAIToolParameterObject,
+    IAIToolParameterArray,
+    IAIToolParameterPrimitive,
+    IRWSHistoryMessage,
+    InputType,
+    CompoundInput,
+    IToolCall,
+    ToolHandler
+};
+