@ruvector/ruvllm 2.6.0 → 2.6.2

package/dist/cjs/rlm/controller.js

@@ -0,0 +1,554 @@
+"use strict";
+/**
+ * RLM Controller - Recursive Retrieval Language Model
+ *
+ * Implements a recursive retrieval-augmented generation system that:
+ * 1. Breaks down complex queries into sub-queries
+ * 2. Retrieves relevant memory spans for each query
+ * 3. Synthesizes coherent answers from retrieved context
+ * 4. Optionally reflects on and refines answers
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { RlmController } from '@ruvector/ruvllm';
+ *
+ * const rlm = new RlmController({
+ *   maxDepth: 3,
+ *   retrievalTopK: 10,
+ *   enableCache: true,
+ * });
+ *
+ * // Add knowledge to memory
+ * await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
+ * await rlm.addMemory('Deep learning uses neural networks with many layers.');
+ *
+ * // Query with recursive retrieval
+ * const answer = await rlm.query('Explain the relationship between ML and deep learning');
+ * console.log(answer.text);
+ * console.log('Sources:', answer.sources.length);
+ * console.log('Confidence:', answer.confidence);
+ * ```
+ *
+ * @example Streaming
+ * ```typescript
+ * const rlm = new RlmController();
+ *
+ * for await (const event of rlm.queryStream('What is AI?')) {
+ *   if (event.type === 'token') {
+ *     process.stdout.write(event.text);
+ *   } else {
+ *     console.log('\n\nDone! Quality:', event.answer.qualityScore);
+ *   }
+ * }
+ * ```
+ *
+ * @example With Reflection
+ * ```typescript
+ * const rlm = new RlmController({
+ *   enableReflection: true,
+ *   maxReflectionIterations: 2,
+ *   minQualityScore: 0.8,
+ * });
+ *
+ * const answer = await rlm.query('Complex multi-part question...');
+ * // Answer will be iteratively refined until quality >= 0.8
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RlmController = void 0;
+const engine_1 = require("../engine");
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    maxDepth: 3,
+    maxSubQueries: 5,
+    tokenBudget: 4096,
+    enableCache: true,
+    cacheTtl: 300000, // 5 minutes
+    retrievalTopK: 10,
+    minQualityScore: 0.7,
+    enableReflection: false,
+    maxReflectionIterations: 2,
+};
+/**
+ * RlmController - Recursive Retrieval Language Model Controller
+ *
+ * Orchestrates retrieval-augmented generation with recursive sub-query
+ * decomposition, memory search, and optional self-reflection.
+ */
+class RlmController {
+    /**
+     * Create a new RLM controller
+     *
+     * @param config - Configuration options
+     * @param engine - Optional RuvLLM engine instance (creates new if not provided)
+     *
+     * @example
+     * ```typescript
+     * // With default config
+     * const rlm = new RlmController();
+     *
+     * // With custom config
+     * const rlm = new RlmController({
+     *   maxDepth: 5,
+     *   enableReflection: true,
+     * });
+     *
+     * // With existing engine
+     * const engine = new RuvLLM({ learningEnabled: true });
+     * const rlm = new RlmController({}, engine);
+     * ```
+     */
+    constructor(config, engine) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.cache = new Map();
+        this.engine = engine ?? new engine_1.RuvLLM({ learningEnabled: true });
+        this.memoryIdCounter = 0;
+    }
+    /**
+     * Query the RLM with recursive retrieval
+     *
+     * @param input - The query string
+     * @returns Promise resolving to the answer with sources and metadata
+     *
+     * @example
+     * ```typescript
+     * const answer = await rlm.query('What is the capital of France?');
+     * console.log(answer.text); // "The capital of France is Paris..."
+     * console.log(answer.confidence); // 0.95
+     * console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
+     * ```
+     */
+    async query(input) {
+        // Check cache first
+        if (this.config.enableCache) {
+            const cached = this.getCached(input);
+            if (cached) {
+                return { ...cached, cached: true };
+            }
+        }
+        // Retrieve relevant memory spans
+        const sources = await this.searchMemory(input, this.config.retrievalTopK);
+        // Generate sub-queries if needed and depth allows
+        const subQueries = await this.generateSubQueries(input, sources, 0);
+        // Build context from sources and sub-query answers
+        const context = this.buildContext(sources, subQueries);
+        // Generate the answer
+        const startTime = Date.now();
+        const response = this.engine.query(this.buildPrompt(input, context), this.getGenerationConfig());
+        // Calculate token usage (estimate if not provided by engine)
+        const tokenUsage = this.estimateTokenUsage(input, context, response.text);
+        // Calculate quality score
+        const qualityScore = this.calculateQualityScore(sources, response.confidence);
+        let answer = {
+            text: response.text,
+            confidence: response.confidence,
+            qualityScore,
+            sources,
+            subQueries: subQueries.length > 0 ? subQueries : undefined,
+            tokenUsage,
+            cached: false,
+        };
+        // Apply reflection if enabled and quality is below threshold
+        if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {
+            answer = await this.applyReflection(input, answer);
+        }
+        // Cache the result
+        if (this.config.enableCache) {
+            this.setCache(input, answer);
+        }
+        return answer;
+    }
+    /**
+     * Query with streaming response
+     *
+     * @param input - The query string
+     * @yields StreamToken events (either partial tokens or final answer)
+     *
+     * @example
+     * ```typescript
+     * for await (const event of rlm.queryStream('Explain quantum computing')) {
+     *   if (event.type === 'token') {
+     *     // Partial token received
+     *     process.stdout.write(event.text);
+     *   } else {
+     *     // Generation complete
+     *     console.log('\n\nSources:', event.answer.sources.length);
+     *   }
+     * }
+     * ```
+     */
+    async *queryStream(input) {
+        // Check cache first
+        if (this.config.enableCache) {
+            const cached = this.getCached(input);
+            if (cached) {
+                // Simulate streaming for cached response
+                const words = cached.text.split(' ');
+                for (const word of words) {
+                    yield { type: 'token', text: word + ' ', done: false };
+                    await this.delay(10); // Small delay for realistic streaming
+                }
+                yield { type: 'done', answer: { ...cached, cached: true }, done: true };
+                return;
+            }
+        }
+        // Retrieve sources
+        const sources = await this.searchMemory(input, this.config.retrievalTopK);
+        const subQueries = await this.generateSubQueries(input, sources, 0);
+        const context = this.buildContext(sources, subQueries);
+        // Generate with simulated streaming
+        const prompt = this.buildPrompt(input, context);
+        const response = this.engine.query(prompt, this.getGenerationConfig());
+        // Stream the response word by word
+        const words = response.text.split(' ');
+        let streamedText = '';
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i];
+            const text = i < words.length - 1 ? word + ' ' : word;
+            streamedText += text;
+            yield { type: 'token', text, done: false };
+            await this.delay(20); // Simulate generation latency
+        }
+        const tokenUsage = this.estimateTokenUsage(input, context, streamedText);
+        const qualityScore = this.calculateQualityScore(sources, response.confidence);
+        const answer = {
+            text: streamedText,
+            confidence: response.confidence,
+            qualityScore,
+            sources,
+            subQueries: subQueries.length > 0 ? subQueries : undefined,
+            tokenUsage,
+            cached: false,
+        };
+        // Cache the result
+        if (this.config.enableCache) {
+            this.setCache(input, answer);
+        }
+        yield { type: 'done', answer, done: true };
+    }
+    /**
+     * Add content to memory for retrieval
+     *
+     * @param text - The text content to store
+     * @param metadata - Optional metadata to associate with the memory
+     * @returns Promise resolving to the memory span ID
+     *
+     * @example
+     * ```typescript
+     * const id1 = await rlm.addMemory(
+     *   'TypeScript is a typed superset of JavaScript.',
+     *   { source: 'documentation', category: 'programming' }
+     * );
+     *
+     * const id2 = await rlm.addMemory(
+     *   'React is a JavaScript library for building UIs.'
+     * );
+     * ```
+     */
+    async addMemory(text, metadata) {
+        const nodeId = this.engine.addMemory(text, metadata);
+        const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;
+        return id;
+    }
+    /**
+     * Search memory for relevant spans
+     *
+     * @param query - The search query
+     * @param topK - Number of results to return (default: config.retrievalTopK)
+     * @returns Promise resolving to array of memory spans
+     *
+     * @example
+     * ```typescript
+     * const spans = await rlm.searchMemory('JavaScript frameworks', 5);
+     * for (const span of spans) {
+     *   console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
+     * }
+     * ```
+     */
+    async searchMemory(query, topK) {
+        const k = topK ?? this.config.retrievalTopK;
+        const results = this.engine.searchMemory(query, k);
+        return results.map((result, index) => ({
+            id: `rlm-span-${result.id}-${index}`,
+            text: result.content,
+            similarityScore: result.score,
+            source: result.metadata?.source,
+            metadata: result.metadata,
+        }));
+    }
+    /**
+     * Clear the response cache
+     *
+     * @example
+     * ```typescript
+     * rlm.clearCache();
+     * console.log('Cache cleared');
+     * ```
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get current cache statistics
+     *
+     * @returns Object with cache size and hit rate info
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            entries: this.cache.size,
+        };
+    }
+    /**
+     * Update configuration at runtime
+     *
+     * @param config - Partial configuration to merge
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    /**
+     * Generate sub-queries for complex questions
+     */
+    async generateSubQueries(query, sources, depth) {
+        if (depth >= this.config.maxDepth) {
+            return [];
+        }
+        // Simple heuristic: generate sub-queries for questions with multiple parts
+        const subQueries = [];
+        const parts = this.decomposeQuery(query);
+        for (const part of parts.slice(0, this.config.maxSubQueries)) {
+            if (part.trim().length < 10)
+                continue;
+            // Search for sub-query specific sources
+            const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));
+            const context = this.buildContext(subSources, []);
+            const response = this.engine.query(this.buildPrompt(part, context), { ...this.getGenerationConfig(), maxTokens: 256 });
+            subQueries.push({
+                query: part,
+                answer: response.text,
+                depth: depth + 1,
+            });
+        }
+        return subQueries;
+    }
+    /**
+     * Decompose a complex query into simpler parts
+     */
+    decomposeQuery(query) {
+        // Split on common conjunctions and question markers
+        const parts = [];
+        // Check for multi-part questions
+        const conjunctions = [' and ', ' or ', '. ', '? ', '; '];
+        let current = query;
+        for (const conj of conjunctions) {
+            if (current.includes(conj)) {
+                const split = current.split(conj);
+                parts.push(...split.filter(p => p.trim().length > 10));
+                current = '';
+                break;
+            }
+        }
+        // If no decomposition happened, return original
+        if (parts.length === 0) {
+            return [query];
+        }
+        return parts;
+    }
+    /**
+     * Build context string from sources and sub-queries
+     */
+    buildContext(sources, subQueries) {
+        const parts = [];
+        // Add sources
+        if (sources.length > 0) {
+            parts.push('Relevant context:');
+            for (const source of sources) {
+                parts.push(`- ${source.text}`);
+            }
+        }
+        // Add sub-query answers
+        if (subQueries.length > 0) {
+            parts.push('\nRelated information:');
+            for (const sq of subQueries) {
+                parts.push(`Q: ${sq.query}`);
+                parts.push(`A: ${sq.answer}`);
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Build the full prompt with context
+     */
+    buildPrompt(query, context) {
+        if (context.trim().length === 0) {
+            return query;
+        }
+        return `${context}\n\nBased on the above context, answer the following question:\n${query}`;
+    }
+    /**
+     * Get generation config based on RLM settings
+     */
+    getGenerationConfig() {
+        return {
+            maxTokens: Math.min(this.config.tokenBudget, 2048),
+            temperature: 0.7,
+            topP: 0.9,
+        };
+    }
+    /**
+     * Estimate token usage
+     */
+    estimateTokenUsage(query, context, response) {
+        // Rough estimation: ~4 characters per token
+        const promptTokens = Math.ceil((query.length + context.length) / 4);
+        const completionTokens = Math.ceil(response.length / 4);
+        return {
+            prompt: promptTokens,
+            completion: completionTokens,
+            total: promptTokens + completionTokens,
+        };
+    }
+    /**
+     * Calculate quality score based on sources and confidence
+     */
+    calculateQualityScore(sources, confidence) {
+        if (sources.length === 0) {
+            return confidence * 0.5; // Penalize answers without sources
+        }
+        // Average source similarity
+        const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;
+        // Weighted combination
+        return confidence * 0.6 + avgSimilarity * 0.4;
+    }
+    /**
+     * Apply self-reflection to improve answer
+     */
+    async applyReflection(query, answer) {
+        let currentAnswer = answer;
+        let iterations = 0;
+        while (iterations < this.config.maxReflectionIterations &&
+            currentAnswer.qualityScore < this.config.minQualityScore) {
+            iterations++;
+            // Generate critique
+            const critiquePrompt = `Evaluate this answer for accuracy and completeness:
+Question: ${query}
+Answer: ${currentAnswer.text}
+
+Provide a brief critique and suggest improvements.`;
+            const critiqueResponse = this.engine.query(critiquePrompt, {
+                maxTokens: 256,
+                temperature: 0.5,
+            });
+            // Generate improved answer
+            const improvePrompt = `Based on this feedback: "${critiqueResponse.text}"
+
+Improve this answer:
+Question: ${query}
+Original: ${currentAnswer.text}
+
+Provide an improved answer:`;
+            const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());
+            // Update answer with reflection improvements
+            const newQualityScore = Math.min(1.0, currentAnswer.qualityScore + 0.1 * iterations);
+            currentAnswer = {
+                ...currentAnswer,
+                text: improvedResponse.text,
+                confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),
+                qualityScore: newQualityScore,
+                tokenUsage: {
+                    prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens
+                    completion: currentAnswer.tokenUsage.completion + 100,
+                    total: currentAnswer.tokenUsage.total + 200,
+                },
+            };
+        }
+        return currentAnswer;
+    }
+    /**
+     * Get cached answer if valid
+     */
+    getCached(query) {
+        const hash = this.hashQuery(query);
+        const entry = this.cache.get(hash);
+        if (!entry) {
+            return null;
+        }
+        // Check TTL
+        if (Date.now() - entry.timestamp > this.config.cacheTtl) {
+            this.cache.delete(hash);
+            return null;
+        }
+        return entry.answer;
+    }
+    /**
+     * Set cache entry
+     */
+    setCache(query, answer) {
+        const hash = this.hashQuery(query);
+        this.cache.set(hash, {
+            answer,
+            timestamp: Date.now(),
+            queryHash: hash,
+        });
+        // Prune old entries if cache gets too large
+        if (this.cache.size > 1000) {
+            this.pruneCache();
+        }
+    }
+    /**
+     * Simple hash function for cache keys
+     */
+    hashQuery(query) {
+        let hash = 0;
+        for (let i = 0; i < query.length; i++) {
+            const char = query.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return `rlm-cache-${hash.toString(16)}`;
+    }
+    /**
+     * Prune expired cache entries
+     */
+    pruneCache() {
+        const now = Date.now();
+        const toDelete = [];
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.config.cacheTtl) {
+                toDelete.push(key);
+            }
+        }
+        // Delete oldest entries if still too large
+        if (this.cache.size - toDelete.length > 800) {
+            const entries = Array.from(this.cache.entries())
+                .sort((a, b) => a[1].timestamp - b[1].timestamp);
+            const deleteCount = entries.length - 500;
+            for (let i = 0; i < deleteCount; i++) {
+                toDelete.push(entries[i][0]);
+            }
+        }
+        for (const key of toDelete) {
+            this.cache.delete(key);
+        }
+    }
+    /**
+     * Utility delay function for streaming simulation
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.RlmController = RlmController;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RLM Controller - Recursive Retrieval Language Model\n *\n * Implements a recursive retrieval-augmented generation system that:\n * 1. Breaks down complex queries into sub-queries\n * 2. Retrieves relevant memory spans for each query\n * 3. Synthesizes coherent answers from retrieved context\n * 4. Optionally reflects on and refines answers\n *\n * @example Basic Usage\n * ```typescript\n * import { RlmController } from '@ruvector/ruvllm';\n *\n * const rlm = new RlmController({\n *   maxDepth: 3,\n *   retrievalTopK: 10,\n *   enableCache: true,\n * });\n *\n * // Add knowledge to memory\n * await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');\n * await rlm.addMemory('Deep learning uses neural networks with many layers.');\n *\n * // Query with recursive retrieval\n * const answer = await rlm.query('Explain the relationship between ML and deep learning');\n * console.log(answer.text);\n * console.log('Sources:', answer.sources.length);\n * console.log('Confidence:', answer.confidence);\n * ```\n *\n * @example Streaming\n * ```typescript\n * const rlm = new RlmController();\n *\n * for await (const event of rlm.queryStream('What is AI?')) {\n *   if (event.type === 'token') {\n *     process.stdout.write(event.text);\n *   } else {\n *     console.log('\\n\\nDone! Quality:', event.answer.qualityScore);\n *   }\n * }\n * ```\n *\n * @example With Reflection\n * ```typescript\n * const rlm = new RlmController({\n *   enableReflection: true,\n *   maxReflectionIterations: 2,\n *   minQualityScore: 0.8,\n * });\n *\n * const answer = await rlm.query('Complex multi-part question...');\n * // Answer will be iteratively refined until quality >= 0.8\n * ```\n */\n\nimport {\n  RlmConfig,\n  RlmAnswer,\n  MemorySpan,\n  SubQuery,\n  TokenUsage,\n  StreamToken,\n  RlmCacheEntry,\n  ReflectionResult,\n} from './types';\n\nimport { RuvLLM } from '../engine';\nimport type { GenerationConfig, QueryResponse } from '../types';\n\n/**\n * Default configuration values\n */\nconst DEFAULT_CONFIG: Required<RlmConfig> = {\n  maxDepth: 3,\n  maxSubQueries: 5,\n  tokenBudget: 4096,\n  enableCache: true,\n  cacheTtl: 300000, // 5 minutes\n  retrievalTopK: 10,\n  minQualityScore: 0.7,\n  enableReflection: false,\n  maxReflectionIterations: 2,\n};\n\n/**\n * RlmController - Recursive Retrieval Language Model Controller\n *\n * Orchestrates retrieval-augmented generation with recursive sub-query\n * decomposition, memory search, and optional self-reflection.\n */\nexport class RlmController {\n  private config: Required<RlmConfig>;\n  private cache: Map<string, RlmCacheEntry>;\n  private engine: RuvLLM;\n  private memoryIdCounter: number;\n\n  /**\n   * Create a new RLM controller\n   *\n   * @param config - Configuration options\n   * @param engine - Optional RuvLLM engine instance (creates new if not provided)\n   *\n   * @example\n   * ```typescript\n   * // With default config\n   * const rlm = new RlmController();\n   *\n   * // With custom config\n   * const rlm = new RlmController({\n   *   maxDepth: 5,\n   *   enableReflection: true,\n   * });\n   *\n   * // With existing engine\n   * const engine = new RuvLLM({ learningEnabled: true });\n   * const rlm = new RlmController({}, engine);\n   * ```\n   */\n  constructor(config?: RlmConfig, engine?: RuvLLM) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    this.cache = new Map();\n    this.engine = engine ?? new RuvLLM({ learningEnabled: true });\n    this.memoryIdCounter = 0;\n  }\n\n  /**\n   * Query the RLM with recursive retrieval\n   *\n   * @param input - The query string\n   * @returns Promise resolving to the answer with sources and metadata\n   *\n   * @example\n   * ```typescript\n   * const answer = await rlm.query('What is the capital of France?');\n   * console.log(answer.text); // \"The capital of France is Paris...\"\n   * console.log(answer.confidence); // 0.95\n   * console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]\n   * ```\n   */\n  async query(input: string): Promise<RlmAnswer> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        return { ...cached, cached: true };\n      }\n    }\n\n    // Retrieve relevant memory spans\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n\n    // Generate sub-queries if needed and depth allows\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n\n    // Build context from sources and sub-query answers\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate the answer\n    const startTime = Date.now();\n    const response = this.engine.query(\n      this.buildPrompt(input, context),\n      this.getGenerationConfig()\n    );\n\n    // Calculate token usage (estimate if not provided by engine)\n    const tokenUsage = this.estimateTokenUsage(input, context, response.text);\n\n    // Calculate quality score\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    let answer: RlmAnswer = {\n      text: response.text,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Apply reflection if enabled and quality is below threshold\n    if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {\n      answer = await this.applyReflection(input, answer);\n    }\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    return answer;\n  }\n\n  /**\n   * Query with streaming response\n   *\n   * @param input - The query string\n   * @yields StreamToken events (either partial tokens or final answer)\n   *\n   * @example\n   * ```typescript\n   * for await (const event of rlm.queryStream('Explain quantum computing')) {\n   *   if (event.type === 'token') {\n   *     // Partial token received\n   *     process.stdout.write(event.text);\n   *   } else {\n   *     // Generation complete\n   *     console.log('\\n\\nSources:', event.answer.sources.length);\n   *   }\n   * }\n   * ```\n   */\n  async *queryStream(input: string): AsyncGenerator<StreamToken> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        // Simulate streaming for cached response\n        const words = cached.text.split(' ');\n        for (const word of words) {\n          yield { type: 'token', text: word + ' ', done: false };\n          await this.delay(10); // Small delay for realistic streaming\n        }\n        yield { type: 'done', answer: { ...cached, cached: true }, done: true };\n        return;\n      }\n    }\n\n    // Retrieve sources\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate with simulated streaming\n    const prompt = this.buildPrompt(input, context);\n    const response = this.engine.query(prompt, this.getGenerationConfig());\n\n    // Stream the response word by word\n    const words = response.text.split(' ');\n    let streamedText = '';\n\n    for (let i = 0; i < words.length; i++) {\n      const word = words[i];\n      const text = i < words.length - 1 ? word + ' ' : word;\n      streamedText += text;\n\n      yield { type: 'token', text, done: false };\n      await this.delay(20); // Simulate generation latency\n    }\n\n    const tokenUsage = this.estimateTokenUsage(input, context, streamedText);\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    const answer: RlmAnswer = {\n      text: streamedText,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    yield { type: 'done', answer, done: true };\n  }\n\n  /**\n   * Add content to memory for retrieval\n   *\n   * @param text - The text content to store\n   * @param metadata - Optional metadata to associate with the memory\n   * @returns Promise resolving to the memory span ID\n   *\n   * @example\n   * ```typescript\n   * const id1 = await rlm.addMemory(\n   *   'TypeScript is a typed superset of JavaScript.',\n   *   { source: 'documentation', category: 'programming' }\n   * );\n   *\n   * const id2 = await rlm.addMemory(\n   *   'React is a JavaScript library for building UIs.'\n   * );\n   * ```\n   */\n  async addMemory(text: string, metadata?: Record<string, unknown>): Promise<string> {\n    const nodeId = this.engine.addMemory(text, metadata);\n    const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;\n    return id;\n  }\n\n  /**\n   * Search memory for relevant spans\n   *\n   * @param query - The search query\n   * @param topK - Number of results to return (default: config.retrievalTopK)\n   * @returns Promise resolving to array of memory spans\n   *\n   * @example\n   * ```typescript\n   * const spans = await rlm.searchMemory('JavaScript frameworks', 5);\n   * for (const span of spans) {\n   *   console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);\n   * }\n   * ```\n   */\n  async searchMemory(query: string, topK?: number): Promise<MemorySpan[]> {\n    const k = topK ?? this.config.retrievalTopK;\n    const results = this.engine.searchMemory(query, k);\n\n    return results.map((result, index) => ({\n      id: `rlm-span-${result.id}-${index}`,\n      text: result.content,\n      similarityScore: result.score,\n      source: result.metadata?.source as string | undefined,\n      metadata: result.metadata,\n    }));\n  }\n\n  /**\n   * Clear the response cache\n   *\n   * @example\n   * ```typescript\n   * rlm.clearCache();\n   * console.log('Cache cleared');\n   * ```\n   */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get current cache statistics\n   *\n   * @returns Object with cache size and hit rate info\n   */\n  getCacheStats(): { size: number; entries: number } {\n    return {\n      size: this.cache.size,\n      entries: this.cache.size,\n    };\n  }\n\n  /**\n   * Update configuration at runtime\n   *\n   * @param config - Partial configuration to merge\n   */\n  updateConfig(config: Partial<RlmConfig>): void {\n    this.config = { ...this.config, ...config };\n  }\n\n  /**\n   * Get current configuration\n   */\n  getConfig(): Required<RlmConfig> {\n    return { ...this.config };\n  }\n\n  // ============================================\n  // Private Methods\n  // ============================================\n\n  /**\n   * Generate sub-queries for complex questions\n   */\n  private async generateSubQueries(\n    query: string,\n    sources: MemorySpan[],\n    depth: number\n  ): Promise<SubQuery[]> {\n    if (depth >= this.config.maxDepth) {\n      return [];\n    }\n\n    // Simple heuristic: generate sub-queries for questions with multiple parts\n    const subQueries: SubQuery[] = [];\n    const parts = this.decomposeQuery(query);\n\n    for (const part of parts.slice(0, this.config.maxSubQueries)) {\n      if (part.trim().length < 10) continue;\n\n      // Search for sub-query specific sources\n      const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));\n      const context = this.buildContext(subSources, []);\n      const response = this.engine.query(\n        this.buildPrompt(part, context),\n        { ...this.getGenerationConfig(), maxTokens: 256 }\n      );\n\n      subQueries.push({\n        query: part,\n        answer: response.text,\n        depth: depth + 1,\n      });\n    }\n\n    return subQueries;\n  }\n\n  /**\n   * Decompose a complex query into simpler parts\n   */\n  private decomposeQuery(query: string): string[] {\n    // Split on common conjunctions and question markers\n    const parts: string[] = [];\n\n    // Check for multi-part questions\n    const conjunctions = [' and ', ' or ', '. ', '? ', '; '];\n    let current = query;\n\n    for (const conj of conjunctions) {\n      if (current.includes(conj)) {\n        const split = current.split(conj);\n        parts.push(...split.filter(p => p.trim().length > 10));\n        current = '';\n        break;\n      }\n    }\n\n    // If no decomposition happened, return original\n    if (parts.length === 0) {\n      return [query];\n    }\n\n    return parts;\n  }\n\n  /**\n   * Build context string from sources and sub-queries\n   */\n  private buildContext(sources: MemorySpan[], subQueries: SubQuery[]): string {\n    const parts: string[] = [];\n\n    // Add sources\n    if (sources.length > 0) {\n      parts.push('Relevant context:');\n      for (const source of sources) {\n        parts.push(`- ${source.text}`);\n      }\n    }\n\n    // Add sub-query answers\n    if (subQueries.length > 0) {\n      parts.push('\\nRelated information:');\n      for (const sq of subQueries) {\n        parts.push(`Q: ${sq.query}`);\n        parts.push(`A: ${sq.answer}`);\n      }\n    }\n\n    return parts.join('\\n');\n  }\n\n  /**\n   * Build the full prompt with context\n   */\n  private buildPrompt(query: string, context: string): string {\n    if (context.trim().length === 0) {\n      return query;\n    }\n\n    return `${context}\\n\\nBased on the above context, answer the following question:\\n${query}`;\n  }\n\n  /**\n   * Get generation config based on RLM settings\n   */\n  private getGenerationConfig(): GenerationConfig {\n    return {\n      maxTokens: Math.min(this.config.tokenBudget, 2048),\n      temperature: 0.7,\n      topP: 0.9,\n    };\n  }\n\n  /**\n   * Estimate token usage\n   */\n  private estimateTokenUsage(query: string, context: string, response: string): TokenUsage {\n    // Rough estimation: ~4 characters per token\n    const promptTokens = Math.ceil((query.length + context.length) / 4);\n    const completionTokens = Math.ceil(response.length / 4);\n\n    return {\n      prompt: promptTokens,\n      completion: completionTokens,\n      total: promptTokens + completionTokens,\n    };\n  }\n\n  /**\n   * Calculate quality score based on sources and confidence\n   */\n  private calculateQualityScore(sources: MemorySpan[], confidence: number): number {\n    if (sources.length === 0) {\n      return confidence * 0.5; // Penalize answers without sources\n    }\n\n    // Average source similarity\n    const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;\n\n    // Weighted combination\n    return confidence * 0.6 + avgSimilarity * 0.4;\n  }\n\n  /**\n   * Apply self-reflection to improve answer\n   */\n  private async applyReflection(\n    query: string,\n    answer: RlmAnswer\n  ): Promise<RlmAnswer> {\n    let currentAnswer = answer;\n    let iterations = 0;\n\n    while (\n      iterations < this.config.maxReflectionIterations &&\n      currentAnswer.qualityScore < this.config.minQualityScore\n    ) {\n      iterations++;\n\n      // Generate critique\n      const critiquePrompt = `Evaluate this answer for accuracy and completeness:\nQuestion: ${query}\nAnswer: ${currentAnswer.text}\n\nProvide a brief critique and suggest improvements.`;\n\n      const critiqueResponse = this.engine.query(critiquePrompt, {\n        maxTokens: 256,\n        temperature: 0.5,\n      });\n\n      // Generate improved answer\n      const improvePrompt = `Based on this feedback: \"${critiqueResponse.text}\"\n\nImprove this answer:\nQuestion: ${query}\nOriginal: ${currentAnswer.text}\n\nProvide an improved answer:`;\n\n      const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());\n\n      // Update answer with reflection improvements\n      const newQualityScore = Math.min(\n        1.0,\n        currentAnswer.qualityScore + 0.1 * iterations\n      );\n\n      currentAnswer = {\n        ...currentAnswer,\n        text: improvedResponse.text,\n        confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),\n        qualityScore: newQualityScore,\n        tokenUsage: {\n          prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens\n          completion: currentAnswer.tokenUsage.completion + 100,\n          total: currentAnswer.tokenUsage.total + 200,\n        },\n      };\n    }\n\n    return currentAnswer;\n  }\n\n  /**\n   * Get cached answer if valid\n   */\n  private getCached(query: string): RlmAnswer | null {\n    const hash = this.hashQuery(query);\n    const entry = this.cache.get(hash);\n\n    if (!entry) {\n      return null;\n    }\n\n    // Check TTL\n    if (Date.now() - entry.timestamp > this.config.cacheTtl) {\n      this.cache.delete(hash);\n      return null;\n    }\n\n    return entry.answer;\n  }\n\n  /**\n   * Set cache entry\n   */\n  private setCache(query: string, answer: RlmAnswer): void {\n    const hash = this.hashQuery(query);\n    this.cache.set(hash, {\n      answer,\n      timestamp: Date.now(),\n      queryHash: hash,\n    });\n\n    // Prune old entries if cache gets too large\n    if (this.cache.size > 1000) {\n      this.pruneCache();\n    }\n  }\n\n  /**\n   * Simple hash function for cache keys\n   */\n  private hashQuery(query: string): string {\n    let hash = 0;\n    for (let i = 0; i < query.length; i++) {\n      const char = query.charCodeAt(i);\n      hash = ((hash << 5) - hash) + char;\n      hash = hash & hash; // Convert to 32-bit integer\n    }\n    return `rlm-cache-${hash.toString(16)}`;\n  }\n\n  /**\n   * Prune expired cache entries\n   */\n  private pruneCache(): void {\n    const now = Date.now();\n    const toDelete: string[] = [];\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (now - entry.timestamp > this.config.cacheTtl) {\n        toDelete.push(key);\n      }\n    }\n\n    // Delete oldest entries if still too large\n    if (this.cache.size - toDelete.length > 800) {\n      const entries = Array.from(this.cache.entries())\n        .sort((a, b) => a[1].timestamp - b[1].timestamp);\n\n      const deleteCount = entries.length - 500;\n      for (let i = 0; i < deleteCount; i++) {\n        toDelete.push(entries[i][0]);\n      }\n    }\n\n    for (const key of toDelete) {\n      this.cache.delete(key);\n    }\n  }\n\n  /**\n   * Utility delay function for streaming simulation\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}