@rws-framework/ai-tools 2.1.1 → 2.2.1

package/package.json

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

package/src/models/prompts/_prompt.ts

@@ -1,327 +1,226 @@
 import { Readable } from 'stream';
-import { PromptTemplate } from '@langchain/core/prompts';
-import { EmbedLoader, IChainCallOutput } from '../convo/EmbedLoader';
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { IToolCall } from '../../types/IPrompt'
+import { ModuleRef } from '@nestjs/core';
 import { 
-    IPromptSender, 
-    IPromptEnchantment, 
-    IPromptParams, 
-    IPromptHyperParameters, 
-    IRWSPromptRequestExecutor, 
-    IRWSPromptStreamExecutor, 
-    IRWSSinglePromptRequestExecutor, 
-    IRWSPromptJSON, 
-    ChainStreamType, 
+    IPromptParams,
+    IRWSPromptRequestExecutor,
+    IRWSPromptStreamExecutor,
+    IRWSSinglePromptRequestExecutor,
+    IRWSPromptJSON,
+    ChainStreamType,
     ILLMChunk,
     IAITool,
     IRWSHistoryMessage,
-    InputType,
     CompoundInput,
-    ToolHandler
-} from '../../types/IPrompt';
-import { IContextToken } from '../../types/IContextToken';
-import { text } from 'stream/consumers';
-
-type EntryParams = {
-    modelId: string,
-    body: string,
-}
-
-
-class RWSPrompt {
+    ToolHandler,
+    IToolCall,
+    IPromptEnchantment,
+    BaseChatModel,
+    PromptTemplate,
+    EmbedLoader
+} from './inc/types';
+import { IChainCallOutput } from './inc/types';
+import { ToolManager } from './inc/tool-manager';
+import { InputOutputManager } from './inc/input-output-manager';
+import { ModelExecutionManager } from './inc/model-execution-manager';
+import { VariableStorageManager } from './inc/variable-storage-manager';
+import { ExecutionMethodsHandler, IPromptInstance } from './inc/execution-methods-handler';
+
+class RWSPrompt implements IPromptInstance {
     public _stream: ChainStreamType;
-    private input: CompoundInput[] = [];    
-    private enhancedInput: IPromptEnchantment[] = [];
-    private sentInput: CompoundInput[] = [];
-    private originalInput: CompoundInput[] = [];
-    private output: string = '';
-    private modelId: string;
-    private modelType: string;
-    private multiTemplate: PromptTemplate;
-    private embedLoader: EmbedLoader<any>;
-    private hyperParameters: IPromptHyperParameters;
     private created_at: Date;
-    private toolHandlers: Map<string, ToolHandler> = new Map();
-    private varStorage: any = {};
+    
+    // Composition over inheritance - use managers for different concerns
+    private toolManager: ToolManager;
+    private ioManager: InputOutputManager;
+    private modelManager: ModelExecutionManager;
+    private varManager: VariableStorageManager;
+    private executionHandler: ExecutionMethodsHandler;
+
+    constructor(params: IPromptParams) {
+        this.toolManager = new ToolManager();
+        this.ioManager = new InputOutputManager(params.input);
+        this.modelManager = new ModelExecutionManager(params.modelId, params.modelType, params.hyperParameters);
+        this.varManager = new VariableStorageManager();
+        this.executionHandler = new ExecutionMethodsHandler();
+        
+        this.created_at = new Date();
+    }
 
-    private onStream = (chunk: string) => {
+    // Delegation methods for tool management
+    setTools(tools: IAITool[]): RWSPrompt {
+        this.toolManager.setTools(tools);
+        return this;
+    }
 
-    };
+    getTools(): IAITool[] {
+        return this.toolManager.getTools();
+    }
 
-    constructor(params: IPromptParams){
-        this.input = params.input;
-        this.originalInput = params.input;
-        this.hyperParameters = params.hyperParameters;
-        this.modelId = params.modelId;
-        this.modelType = params.modelType;
+    getTool(key: string): { definition: IAITool, handler: ToolHandler } | null {
+        return this.toolManager.getTool(key);
+    }
 
-        this.created_at = new Date();
+    registerToolHandlers(toolHandlers: { [key: string]: ToolHandler }): void {
+        this.toolManager.registerToolHandlers(toolHandlers);
     }
 
-    listen(source: string, stream: boolean = true): RWSPrompt
-    {              
-        this.output = '';
+    async callTools<T = unknown, O = unknown>(tools: IToolCall[], moduleRef: ModuleRef, aiToolOptions?: O): Promise<T[]> {
+        return this.toolManager.callTools<T, O>(tools, moduleRef, aiToolOptions);
+    }
 
-        if (!stream) {
-            this.output = source;
-        } else {           
-            this.output += source;
-            this.onStream(source);            
-        }
-        
+    // Delegation methods for input/output management
+    listen(source: string, stream: boolean = true): RWSPrompt {
+        this.ioManager.listen(source, stream);
         return this;
-    }   
+    }
 
-    setStreamCallback(callback: (chunk: string) => void): void
-    {
-        this.onStream = callback;
+    setStreamCallback(callback: (chunk: string) => void): void {
+        this.ioManager.setStreamCallback(callback);
     }
 
-    addEnchantment(enchantment: IPromptEnchantment): void
-    {
-        this.enhancedInput.push(enchantment);              
+    addEnchantment(enchantment: IPromptEnchantment): void {
+        this.ioManager.addEnchantment(enchantment);
     }
 
-    getEnchantedInputs(): IPromptEnchantment[]
-    {
-        return this.enhancedInput;
+    getEnchantedInputs(): IPromptEnchantment[] {
+        return this.ioManager.getEnchantedInputs();
     }
 
-    getModelId(): string
-    {
-        return this.modelId;
+    readSentInput(): CompoundInput[] {
+        return this.ioManager.readSentInput();
     }
 
-    readSentInput(): CompoundInput[]
-    {
-        return this.sentInput;
+    readInput(): CompoundInput[] {
+        return this.ioManager.readInput();
     }
 
-    readInput(): CompoundInput[]
-    {
-        const enchantedInput: CompoundInput[] = this.enhancedInput.map(enchantment => ({ role: 'user', type:  enchantment.input.type, text: enchantment.input.text }));
-        return [...enchantedInput, ...this.input];
+    readBaseInput(): CompoundInput[] {
+        return this.ioManager.readBaseInput();
     }
 
-    
-    readBaseInput(): CompoundInput[]
-    {
-        return this.originalInput;
-    }    
-
-    setBaseInput(input: CompoundInput[]): RWSPrompt
-    {
-        this.originalInput = input;
-        
+    setBaseInput(input: CompoundInput[]): RWSPrompt {
+        this.ioManager.setBaseInput(input);
         return this;
     }
 
-    injestOutput(content: string): RWSPrompt
-    {
-        this.output = content;
-
+    injestOutput(content: string): RWSPrompt {
+        this.ioManager.injestOutput(content);
         return this;
     }
 
-    readOutput(): string
-    {
-        return this.output;
+    readOutput(): string {
+        return this.ioManager.readOutput();
     }
 
-    getHyperParameters<T extends IPromptHyperParameters>(base: any = null): T
-    {        
-        if(base){
-            this.hyperParameters = {...base, ...this.hyperParameters};
-        }
-
-        return this.hyperParameters as T;
+    addInput(content: CompoundInput): RWSPrompt {
+        this.ioManager.addInput(content);
+        return this;
     }
 
-    getHyperParameter<T>(key: keyof IPromptHyperParameters): T
-    {        
-        if(!this.hyperParameters[key]){
-            return null;
-        }
-
-        return this.hyperParameters[key] as T;
+    addHistory(messages: IRWSHistoryMessage[], historyPrompt: string, callback?: (messages: IRWSHistoryMessage[], prompt: string) => void): void {
+        this.ioManager.addHistory(messages, historyPrompt, callback);
     }
 
-    setHyperParameter(key: string, value: any): RWSPrompt
-    {        
-        this.hyperParameters[key] = value;
-        
-        return this;
-    }
-    
-    setHyperParameters(value: any): RWSPrompt
-    {        
-        this.hyperParameters = value;
-        
-        return this;
+    async readStreamAsText(readableStream: ReadableStream, callback: (txt: string) => void): Promise<void> {
+        return this.ioManager.readStreamAsText(readableStream, callback);
     }
 
-    setMultiTemplate(template: PromptTemplate): RWSPrompt
-    {
-        this.multiTemplate = template;
-        return this;
+    // Delegation methods for model management
+    getModelId(): string {
+        return this.modelManager.getModelId();
     }
 
-    getMultiTemplate(): PromptTemplate
-    {
-        return this.multiTemplate;
+    getModelMetadata(): [string, string] {
+        return this.modelManager.getModelMetadata();
     }
 
-    setEmbedLoader(embedLoader: EmbedLoader<BaseChatModel>): RWSPrompt
-    {
-        this.embedLoader = embedLoader;        
-        
+    setMultiTemplate(template: PromptTemplate): RWSPrompt {
+        this.modelManager.setMultiTemplate(template);
         return this;
     }
 
-    getEmbedLoader<T extends BaseChatModel>(): EmbedLoader<T>
-    {
-        return this.embedLoader;
+    getMultiTemplate(): PromptTemplate {
+        return this.modelManager.getMultiTemplate();
     }
 
-    replacePromptVar(key: string, val: string)
-    {
-
+    setEmbedLoader(embedLoader: EmbedLoader<BaseChatModel>): RWSPrompt {
+        this.modelManager.setEmbedLoader(embedLoader);
+        return this;
     }
 
-    getModelMetadata(): [string, string]
-    {
-        return [this.modelType, this.modelId];
+    getEmbedLoader<T extends BaseChatModel>(): EmbedLoader<T> {
+        return this.modelManager.getEmbedLoader<T>();
     }
 
-    async requestWith(executor: IRWSPromptRequestExecutor, intruderPrompt: string = null, debugVars: any = {}, tools?: IAITool[]): Promise<void>
-    {
-        this.sentInput = this.input;
-        const returnedRWS = await executor.promptRequest(this, { intruderPrompt, debugVars, tools });
-        this.output = returnedRWS.readOutput();        
+    getHyperParameters<T extends any>(base: any = null): T {
+        return this.modelManager.getHyperParameters<T>(base);
     }
 
-    async singleRequestWith(executor: IRWSSinglePromptRequestExecutor, intruderPrompt: string = null, ensureJson: boolean = false, tools?: IAITool[]): Promise<void>
-    {        
-        await executor.singlePromptRequest(this, { intruderPrompt, ensureJson, tools });
-        this.sentInput = this.input;
+    getHyperParameter<T>(key: string): T {
+        return this.modelManager.getHyperParameter<T>(key as any);
     }
 
-    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, tools });
+    setHyperParameter(key: string, value: any): RWSPrompt {
+        this.modelManager.setHyperParameter(key, value);
+        return this;
     }
 
-    addInput(content: CompoundInput): RWSPrompt
-    {
-        this.input.push(content);
+    setHyperParameters(value: any): RWSPrompt {
+        this.modelManager.setHyperParameters(value);
         return this;
     }
 
-    getVar<T>(key: string): T
-    {
-        return Object.keys(this.varStorage).includes(key) ? this.varStorage[key] : null;
+    replacePromptVar(key: string, val: string): void {
+        this.modelManager.replacePromptVar(key, val);
     }
 
-    setVar<T>(key: string, val: T): RWSPrompt {
-        this.varStorage[key] = val;
+    // Delegation methods for variable storage
+    getVar<T>(key: string): T {
+        return this.varManager.getVar<T>(key);
+    }
 
+    setVar<T>(key: string, val: T): RWSPrompt {
+        this.varManager.setVar<T>(key, val);
         return this;
-    } 
-
-    private async isChainStreamType(source: any): Promise<boolean> {
-        if (source && typeof source[Symbol.asyncIterator] === 'function') {
-            const asyncIterator = source[Symbol.asyncIterator]();
-            if (typeof asyncIterator.next === 'function' && 
-                typeof asyncIterator.throw === 'function' && 
-                typeof asyncIterator.return === 'function') {
-                try {
-                    // Optionally check if the next method yields a value of the expected type
-                    const { value, done } = await asyncIterator.next();
-                    return !done && value instanceof ReadableStream; // or whatever check makes sense for IterableReadableStream<ChainValues>
-                } catch (error) {
-                    // Handle or ignore error
-                }
-            }
-        }
-        return false;
-    }
-
-    async readStreamAsText(readableStream: ReadableStream, callback: (txt: string) => void) {
-        const reader = readableStream.getReader();
-                
-        let readResult: any;
-
-        // Continuously read from the stream
-        while (!(readResult = await reader.read()).done) {
-            
-            if (readResult.value && readResult.value.response) {
-                // Emit each chunk text as it's read
-                callback(readResult.value.response);
-            }          
-        }
-        
     }
 
-    addHistory(messages: IRWSHistoryMessage[], historyPrompt: string, callback?: (messages: IRWSHistoryMessage[], prompt: string) => void){
-        const prompt = `
-            ${messages.map(message => `
-                ${message.creator}: ${message.content}
-            `).join('\n\n')}
-            ${historyPrompt}
-        ` ;
-
-        if(callback){
-            callback(messages, prompt);
-        }else{
-            this.input =  [{type: 'text', text: prompt}, ...this.input];
-        }
+    // Delegation methods for execution
+    async requestWith(executor: IRWSPromptRequestExecutor, intruderPrompt: string = null, debugVars: any = {}, tools?: IAITool[]): Promise<void> {
+        return this.executionHandler.requestWith(this, executor, intruderPrompt, debugVars, tools);
     }
 
-    registerToolHandlers(toolHandlers: { [key: string]: ToolHandler }){
-        for(const key of Object.keys(toolHandlers)){
-            this.toolHandlers.set(key, toolHandlers[key]);
-        }        
+    async singleRequestWith(executor: IRWSSinglePromptRequestExecutor, intruderPrompt: string = null, ensureJson: boolean = false, tools?: IAITool[]): Promise<void> {
+        return this.executionHandler.singleRequestWith(this, executor, intruderPrompt, ensureJson, tools);
     }
 
-    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);
-                }                
-            }
-        }
+    async streamWith(executor: IRWSPromptStreamExecutor, read: (chunk: ILLMChunk) => void, end: () => void = () => { }, debugVars: any = {}, tools?: IAITool[]): Promise<RWSPrompt> {
+        return this.executionHandler.streamWith(this, executor, read, end, debugVars, tools);
+    }
 
-        return results;
+    // IPromptInstance interface implementation
+    getInput(): CompoundInput[] {
+        return this.ioManager.getInput();
     }
 
-    private async callAiTool<T>(tool: IToolCall): Promise<T>
-    {
-        const handler = this.toolHandlers.get(tool.name);
-        return await handler(tool.arguments);
+    setSentInput(input: CompoundInput[]): void {
+        this.ioManager.setSentInput(input);
     }
 
-    toJSON(): IRWSPromptJSON
-    {
+    toJSON(): IRWSPromptJSON {
         return {
-            input: this.input,            
-            enhancedInput: this.enhancedInput,
-            sentInput: this.sentInput,
-            originalInput: this.originalInput,
-            output: this.output,
-            modelId: this.modelId,
-            modelType: this.modelType,
-            multiTemplate: this.multiTemplate,            
+            input: this.ioManager.getInput(),
+            enhancedInput: this.ioManager.getEnhancedInput(),
+            sentInput: this.ioManager.readSentInput(),
+            originalInput: this.ioManager.getOriginalInput(),
+            output: this.ioManager.getOutput(),
+            modelId: this.modelManager.getModelId(),
+            modelType: this.modelManager.getModelType(),
+            multiTemplate: this.modelManager.getMultiTemplate(),
             embed: {
-                id: this.embedLoader.getId()
+                id: this.modelManager.getEmbedLoaderId()
             },
-            hyperParameters: this.hyperParameters,
-            var_storage: this.varStorage,
+            hyperParameters: this.modelManager.getAllHyperParameters(),
+            var_storage: this.varManager.getAllVars(),
             created_at: this.created_at.toISOString()
         };
     }

package/src/models/prompts/inc/execution-methods-handler.ts

@@ -0,0 +1,52 @@
+import { 
+    IRWSPromptRequestExecutor,
+    IRWSSinglePromptRequestExecutor,
+    IRWSPromptStreamExecutor,
+    ILLMChunk,
+    IAITool
+} from './types';
+
+export interface IPromptInstance {
+    readOutput(): string;
+    readInput(): any[];
+    getInput(): any[];
+    setSentInput(input: any[]): void;
+    injestOutput(content: string): void;
+}
+
+export class ExecutionMethodsHandler {
+    async requestWith(
+        promptInstance: IPromptInstance,
+        executor: IRWSPromptRequestExecutor, 
+        intruderPrompt: string = null, 
+        debugVars: any = {}, 
+        tools?: IAITool[]
+    ): Promise<void> {
+        promptInstance.setSentInput(promptInstance.getInput());
+        const returnedRWS = await executor.promptRequest(promptInstance as any, { intruderPrompt, debugVars, tools });
+        promptInstance.injestOutput(returnedRWS.readOutput());
+    }
+
+    async singleRequestWith(
+        promptInstance: IPromptInstance,
+        executor: IRWSSinglePromptRequestExecutor, 
+        intruderPrompt: string = null, 
+        ensureJson: boolean = false, 
+        tools?: IAITool[]
+    ): Promise<void> {
+        await executor.singlePromptRequest(promptInstance as any, { intruderPrompt, ensureJson, tools });
+        promptInstance.setSentInput(promptInstance.getInput());
+    }
+
+    async streamWith(
+        promptInstance: IPromptInstance,
+        executor: IRWSPromptStreamExecutor, 
+        read: (chunk: ILLMChunk) => void, 
+        end: () => void = () => { }, 
+        debugVars: any = {}, 
+        tools?: IAITool[]
+    ): Promise<any> {
+        promptInstance.setSentInput(promptInstance.getInput());
+        return executor.promptStream(promptInstance as any, read, end, { debugVars, tools });
+    }
+}

package/src/models/prompts/inc/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export { ToolManager } from './tool-manager';
+export { InputOutputManager } from './input-output-manager';
+export { ModelExecutionManager } from './model-execution-manager';
+export { VariableStorageManager } from './variable-storage-manager';
+export { ExecutionMethodsHandler, IPromptInstance } from './execution-methods-handler';

package/src/models/prompts/inc/input-output-manager.ts

@@ -0,0 +1,120 @@
+import { CompoundInput, IPromptEnchantment, IRWSHistoryMessage } from './types';
+
+export class InputOutputManager {
+    private input: CompoundInput[] = [];
+    private enhancedInput: IPromptEnchantment[] = [];
+    private sentInput: CompoundInput[] = [];
+    private originalInput: CompoundInput[] = [];
+    private output: string = '';
+    private onStream: (chunk: string) => void = () => {};
+
+    constructor(input: CompoundInput[]) {
+        this.input = input;
+        this.originalInput = input;
+    }
+
+    addInput(content: CompoundInput): void {
+        this.input.push(content);
+    }
+
+    addEnchantment(enchantment: IPromptEnchantment): void {
+        this.enhancedInput.push(enchantment);
+    }
+
+    getEnchantedInputs(): IPromptEnchantment[] {
+        return this.enhancedInput;
+    }
+
+    readSentInput(): CompoundInput[] {
+        return this.sentInput;
+    }
+
+    setSentInput(input: CompoundInput[]): void {
+        this.sentInput = input;
+    }
+
+    readInput(): CompoundInput[] {
+        const enchantedInput: CompoundInput[] = this.enhancedInput.map(enchantment => ({ 
+            role: 'user', 
+            type: enchantment.input.type, 
+            text: enchantment.input.text 
+        }));
+        return [...enchantedInput, ...this.input];
+    }
+
+    readBaseInput(): CompoundInput[] {
+        return this.originalInput;
+    }
+
+    setBaseInput(input: CompoundInput[]): void {
+        this.originalInput = input;
+    }
+
+    injestOutput(content: string): void {
+        this.output = content;
+    }
+
+    readOutput(): string {
+        return this.output;
+    }
+
+    listen(source: string, stream: boolean = true): void {
+        this.output = '';
+
+        if (!stream) {
+            this.output = source;
+        } else {
+            this.output += source;
+            this.onStream(source);
+        }
+    }
+
+    setStreamCallback(callback: (chunk: string) => void): void {
+        this.onStream = callback;
+    }
+
+    addHistory(messages: IRWSHistoryMessage[], historyPrompt: string, callback?: (messages: IRWSHistoryMessage[], prompt: string) => void): void {
+        const prompt = `
+            ${messages.map(message => `
+                ${message.creator}: ${message.content}
+            `).join('\n\n')}
+            ${historyPrompt}
+        `;
+
+        if (callback) {
+            callback(messages, prompt);
+        } else {
+            this.input = [{ type: 'text', text: prompt }, ...this.input];
+        }
+    }
+
+    async readStreamAsText(readableStream: ReadableStream, callback: (txt: string) => void): Promise<void> {
+        const reader = readableStream.getReader();
+        let readResult: any;
+
+        // Continuously read from the stream
+        while (!(readResult = await reader.read()).done) {
+            if (readResult.value && readResult.value.response) {
+                // Emit each chunk text as it's read
+                callback(readResult.value.response);
+            }
+        }
+    }
+
+    // Getters for state access
+    getInput(): CompoundInput[] {
+        return this.input;
+    }
+
+    getEnhancedInput(): IPromptEnchantment[] {
+        return this.enhancedInput;
+    }
+
+    getOriginalInput(): CompoundInput[] {
+        return this.originalInput;
+    }
+
+    getOutput(): string {
+        return this.output;
+    }
+}

package/src/models/prompts/inc/model-execution-manager.ts

@@ -0,0 +1,110 @@
+import { 
+    PromptTemplate, 
+    EmbedLoader, 
+    BaseChatModel, 
+    IPromptHyperParameters,
+    IRWSPromptRequestExecutor,
+    IRWSSinglePromptRequestExecutor,
+    IRWSPromptStreamExecutor,
+    ILLMChunk,
+    IAITool,
+    ChainStreamType
+} from './types';
+
+export class ModelExecutionManager {
+    private modelId: string;
+    private modelType: string;
+    private multiTemplate: PromptTemplate;
+    private embedLoader: EmbedLoader<any>;
+    private hyperParameters: IPromptHyperParameters;
+    public _stream: ChainStreamType;
+
+    constructor(modelId: string, modelType: string, hyperParameters: IPromptHyperParameters) {
+        this.modelId = modelId;
+        this.modelType = modelType;
+        this.hyperParameters = hyperParameters;
+    }
+
+    getModelId(): string {
+        return this.modelId;
+    }
+
+    getModelMetadata(): [string, string] {
+        return [this.modelType, this.modelId];
+    }
+
+    setMultiTemplate(template: PromptTemplate): void {
+        this.multiTemplate = template;
+    }
+
+    getMultiTemplate(): PromptTemplate {
+        return this.multiTemplate;
+    }
+
+    setEmbedLoader(embedLoader: EmbedLoader<BaseChatModel>): void {
+        this.embedLoader = embedLoader;
+    }
+
+    getEmbedLoader<T extends BaseChatModel>(): EmbedLoader<T> {
+        return this.embedLoader;
+    }
+
+    getHyperParameters<T = any>(base: any = null): T {
+        if (base) {
+            this.hyperParameters = { ...base, ...this.hyperParameters };
+        }
+
+        return this.hyperParameters as T;
+    }
+
+    getHyperParameter<T>(key: string): T {
+        if (!this.hyperParameters[key]) {
+            return null;
+        }
+
+        return this.hyperParameters[key] as T;
+    }
+
+    setHyperParameter(key: string, value: any): void {
+        this.hyperParameters[key] = value;
+    }
+
+    setHyperParameters(value: any): void {
+        this.hyperParameters = value;
+    }
+
+    replacePromptVar(key: string, val: string): void {
+        // Implementation placeholder
+    }
+
+    private async isChainStreamType(source: any): Promise<boolean> {
+        if (source && typeof source[Symbol.asyncIterator] === 'function') {
+            const asyncIterator = source[Symbol.asyncIterator]();
+            if (typeof asyncIterator.next === 'function' &&
+                typeof asyncIterator.throw === 'function' &&
+                typeof asyncIterator.return === 'function') {
+                try {
+                    // Optionally check if the next method yields a value of the expected type
+                    const { value, done } = await asyncIterator.next();
+                    return !done && value instanceof ReadableStream; // or whatever check makes sense for IterableReadableStream<ChainValues>
+                } catch (error) {
+                    // Handle or ignore error
+                }
+            }
+        }
+        return false;
+    }
+
+    // Getters for state access
+    getModelType(): string {
+        return this.modelType;
+    }
+
+    getEmbedLoaderId(): string {
+        return this.embedLoader?.getId() || null;
+    }
+
+    getAllHyperParameters(): IPromptHyperParameters {
+        return this.hyperParameters;
+    }
+}

package/src/models/prompts/inc/tool-manager.ts

@@ -0,0 +1,57 @@
+import { ModuleRef } from '@nestjs/core';
+import { IAITool, ToolHandler, IToolCall } from './types';
+
+export class ToolManager {
+    private toolHandlers: Map<string, ToolHandler> = new Map();
+    private tools: IAITool[] = [];
+
+    setTools(tools: IAITool[]): void {
+        this.tools = tools;
+    }
+
+    getTools(): IAITool[] {
+        return this.tools;
+    }
+
+    getTool(key: string): { definition: IAITool, handler: ToolHandler } | null {
+        const foundTool = this.tools.find(tool => tool.name === key);
+
+        if (foundTool) {
+            return {
+                definition: foundTool,
+                handler: this.toolHandlers.get(foundTool.name)
+            };
+        }
+
+        return null;
+    }
+
+    registerToolHandlers(toolHandlers: { [key: string]: ToolHandler }): void {        
+        for (const key of Object.keys(toolHandlers)) {
+            this.toolHandlers.set(key, toolHandlers[key]);
+        }
+    }
+
+    async callTools<T = unknown, O = unknown>(tools: IToolCall[], moduleRef: ModuleRef, aiToolOptions?: O): Promise<T[]> {
+        const results: T[] = [];
+        for (const tool of tools) {
+            if (this.toolHandlers.has(tool.function.name)) {
+                const result = await this.callAiTool<T, O>(tool, moduleRef, aiToolOptions);
+                if (result) {
+                    results.push(result);
+                }
+            }
+        }
+
+        return results;
+    }
+
+    private async callAiTool<T, O>(tool: IToolCall, moduleRef: ModuleRef, aiToolOptions?: O): Promise<T> {
+        const handler = this.toolHandlers.get(tool.function.name);
+        return await handler(tool.function.arguments, moduleRef, aiToolOptions);
+    }
+
+    getToolHandlers(): Map<string, ToolHandler> {
+        return this.toolHandlers;
+    }
+}

package/src/models/prompts/inc/types.ts

@@ -0,0 +1,58 @@
+// Re-export commonly used types from IPrompt
+export {
+    IPromptSender,
+    IPromptEnchantment,
+    IPromptParams,
+    IPromptHyperParameters,
+    IRWSPromptRequestExecutor,
+    IRWSPromptStreamExecutor,
+    IRWSSinglePromptRequestExecutor,
+    IRWSPromptJSON,
+    ChainStreamType,
+    ILLMChunk,
+    IAITool,
+    IRWSHistoryMessage,
+    InputType,
+    CompoundInput,
+    ToolHandler,
+    IToolCall
+} from '../../../types/IPrompt';
+
+export { EmbedLoader, IChainCallOutput } from '../../convo/EmbedLoader';
+export { PromptTemplate } from '@langchain/core/prompts';
+export { BaseChatModel } from '@langchain/core/language_models/chat_models';
+export { ModuleRef } from '@nestjs/core';
+export { IContextToken } from '../../../types/IContextToken';
+
+import {
+    CompoundInput,
+    IPromptEnchantment,
+    IPromptHyperParameters,
+    ToolHandler,
+    IAITool
+} from '../../../types/IPrompt';
+import { PromptTemplate } from '@langchain/core/prompts';
+import { EmbedLoader } from '../../convo/EmbedLoader';
+
+export type EntryParams = {
+    modelId: string;
+    body: string;
+};
+
+export interface IRWSPromptState {
+    input: CompoundInput[];
+    enhancedInput: IPromptEnchantment[];
+    sentInput: CompoundInput[];
+    originalInput: CompoundInput[];
+    output: string;
+    modelId: string;
+    modelType: string;
+    multiTemplate: PromptTemplate;
+    embedLoader: EmbedLoader<any>;
+    hyperParameters: IPromptHyperParameters;
+    created_at: Date;
+    toolHandlers: Map<string, ToolHandler>;
+    varStorage: any;
+    tools: IAITool[];
+    onStream: (chunk: string) => void;
+}

package/src/models/prompts/inc/variable-storage-manager.ts

@@ -0,0 +1,27 @@
+export class VariableStorageManager {
+    private varStorage: any = {};
+
+    getVar<T>(key: string): T {
+        return Object.keys(this.varStorage).includes(key) ? this.varStorage[key] : null;
+    }
+
+    setVar<T>(key: string, val: T): void {
+        this.varStorage[key] = val;
+    }
+
+    clearVar(key: string): void {
+        delete this.varStorage[key];
+    }
+
+    clearAllVars(): void {
+        this.varStorage = {};
+    }
+
+    getAllVars(): any {
+        return { ...this.varStorage };
+    }
+
+    hasVar(key: string): boolean {
+        return Object.keys(this.varStorage).includes(key);
+    }
+}

package/src/types/IPrompt.ts

@@ -36,8 +36,12 @@ interface IAIToolSchema {
 
 interface IToolCall {
     id: string;
-    name: string;
-    arguments: Record<string, any>;
+    index: number;
+    type: string;
+    function: {
+      name: string;
+      arguments: string | Record<string, any>
+    };    
   }
 
 interface IAITool {