mark-improving-agent 2.2.0

package/dist/core/cognition/metacognition.js

@@ -0,0 +1,322 @@
+/**
+ * Metacognition - Self-Improving Agent with Metacognitive Capabilities
+ *
+ * Paper: "Self-Improving Agents with Intrinsic Metacognitive Abilities" (2025)
+ * Key mechanisms:
+ * - Performance Monitoring: Track success/failure of reasoning
+ * - Strategy Selection: Choose between different reasoning approaches
+ * - Strategy Execution: Implement selected strategy
+ * - Self-Verification: Verify own outputs
+ * - Confidence Estimation: Know when you don't know
+ *
+ * Paper: "MetaDreamer - Meta-RL for Dream-like Learning"
+ * - Three-level optimization: Environment-specific, Cross-domain, Rapid adaptation
+ */
+import { randomUUID } from 'crypto';
+import { createSelfVerificationEngine } from './self-verification.js';
+const DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+const STRATEGY_SWITCH_THRESHOLD = 0.3;
+const RAPID_ADAPTATION_TASKS = 5;
+export function createMetacognitionEngine() {
+    // Strategy performance tracking
+    const strategyPerformance = new Map();
+    // Initialize strategy performance
+    const strategies = [
+        'direct', 'chain-of-thought', 'self-verified', 'replan', 'multi-path', 'backtrack', 'meta-learn'
+    ];
+    for (const strategy of strategies) {
+        strategyPerformance.set(strategy, {
+            strategy,
+            attempts: 0,
+            successes: 0,
+            failures: 0,
+            avgConfidence: 0.5,
+            avgTimeMs: 0,
+            successRate: 0,
+        });
+    }
+    // Meta-learning history
+    const metaLearningHistory = [];
+    // Current state
+    let currentStrategy = 'chain-of-thought';
+    let totalReasoningCycles = 0;
+    let successfulCycles = 0;
+    let failedCycles = 0;
+    let strategySwitches = 0;
+    let selfCorrections = 0;
+    let totalConfidence = 0;
+    // Self-verification engine
+    const verificationEngine = createSelfVerificationEngine();
+    function updateStrategyPerformance(strategy, success, confidence, timeMs) {
+        const perf = strategyPerformance.get(strategy);
+        perf.attempts++;
+        if (success) {
+            perf.successes++;
+        }
+        else {
+            perf.failures++;
+        }
+        // Running average for confidence
+        perf.avgConfidence = (perf.avgConfidence * (perf.attempts - 1) + confidence) / perf.attempts;
+        // Running average for time
+        perf.avgTimeMs = (perf.avgTimeMs * (perf.attempts - 1) + timeMs) / perf.attempts;
+        // Success rate
+        perf.successRate = perf.successes / perf.attempts;
+    }
+    function monitor(thought, context) {
+        totalReasoningCycles++;
+        return getMetrics();
+    }
+    function evaluate(metrics) {
+        const currentPerf = metrics.strategyPerformance.get(currentStrategy);
+        const alternatives = strategies.filter(s => s !== currentStrategy);
+        // Check if current strategy is failing
+        if (currentPerf.successRate < STRATEGY_SWITCH_THRESHOLD) {
+            const bestAlternative = selectBestStrategy(metrics);
+            return {
+                strategy: bestAlternative.strategy,
+                confidence: bestAlternative.confidence,
+                reason: `Current strategy "${currentStrategy}" has low success rate (${currentPerf.successRate.toFixed(2)})`,
+                alternatives,
+            };
+        }
+        // Check if meta-learning suggests a better strategy
+        const recentTasks = metaLearningHistory.slice(-RAPID_ADAPTATION_TASKS);
+        const taskStrategyMap = new Map();
+        for (const entry of recentTasks) {
+            if (entry.success) {
+                taskStrategyMap.set(entry.task, entry.strategy);
+            }
+        }
+        // If we've seen this type of task, use the learned strategy
+        const matchingEntry = recentTasks.reverse().find(e => e.task === recentTasks[recentTasks.length - 1]?.task);
+        if (matchingEntry?.success) {
+            return {
+                strategy: matchingEntry.strategy,
+                confidence: 0.8,
+                reason: 'Meta-learned strategy from past experience',
+                alternatives,
+            };
+        }
+        return {
+            strategy: currentStrategy,
+            confidence: currentPerf.avgConfidence,
+            reason: `Current strategy performing adequately (${currentPerf.successRate.toFixed(2)})`,
+            alternatives,
+        };
+    }
+    function regulate(strategy) {
+        if (strategy !== currentStrategy) {
+            strategySwitches++;
+            currentStrategy = strategy;
+        }
+    }
+    function plan(task, context) {
+        const executionTrace = [];
+        const startTime = Date.now();
+        // Select best strategy based on current performance
+        const selection = selectBestStrategy(getMetrics());
+        let finalStrategy = selection.strategy;
+        regulate(finalStrategy);
+        const initialStep = {
+            strategy: finalStrategy,
+            thought: `Planning to solve: ${task.slice(0, 100)}...`,
+            confidence: selection.confidence,
+            verified: false,
+            corrected: false,
+            timestamp: Date.now(),
+        };
+        executionTrace.push(initialStep);
+        // Execute with selected strategy
+        const selfImprovements = [];
+        return {
+            id: randomUUID(),
+            initialStrategy: selection.strategy,
+            executionTrace,
+            finalStrategy,
+            success: true, // Will be updated after execution
+            confidence: selection.confidence,
+            selfImprovements,
+            timestamp: startTime,
+        };
+    }
+    async function executeWithStrategy(task, strategy, context) {
+        const startTime = Date.now();
+        regulate(strategy);
+        let result = '';
+        let confidence = 0.5;
+        let verified = false;
+        switch (strategy) {
+            case 'direct':
+                // No reasoning, direct response
+                result = `Direct response to: ${task.slice(0, 50)}...`;
+                confidence = 0.6;
+                verified = true;
+                break;
+            case 'chain-of-thought':
+                // Step-by-step reasoning
+                result = `CoT reasoning for: ${task.slice(0, 50)}...`;
+                confidence = 0.75;
+                break;
+            case 'self-verified':
+                // Reasoning with self-verification
+                const steps = task.split('.');
+                const verifiedSteps = steps.map(step => verificationEngine.verifyStep(step, context));
+                result = verifiedSteps.map(s => s.step).join('. ');
+                confidence = verifiedSteps.reduce((sum, s) => sum + s.confidence, 0) / verifiedSteps.length;
+                verified = verifiedSteps.every(s => s.isValid);
+                if (!verified)
+                    selfCorrections++;
+                break;
+            case 'replan':
+                // Replan based on feedback
+                result = `Replanned approach for: ${task.slice(0, 50)}...`;
+                confidence = 0.7;
+                break;
+            case 'multi-path':
+                // Try multiple approaches
+                result = `Multi-path exploration for: ${task.slice(0, 50)}...`;
+                confidence = 0.8;
+                break;
+            case 'backtrack':
+                // Revert and try alternatives
+                result = `Backtracking approach for: ${task.slice(0, 50)}...`;
+                confidence = 0.65;
+                break;
+            case 'meta-learn':
+                // Meta-learning approach
+                const learnedStrategy = metaLearningHistory
+                    .filter(e => e.task.includes(task.slice(0, 20)))
+                    .sort((a, b) => b.timestamp - a.timestamp)[0];
+                if (learnedStrategy) {
+                    result = `Meta-learned approach for: ${task.slice(0, 50)}...`;
+                    confidence = 0.85;
+                }
+                else {
+                    result = `Exploratory approach for: ${task.slice(0, 50)}...`;
+                    confidence = 0.5;
+                }
+                break;
+        }
+        const timeMs = Date.now() - startTime;
+        const success = confidence >= DEFAULT_CONFIDENCE_THRESHOLD;
+        updateStrategyPerformance(strategy, success, confidence, timeMs);
+        monitor(result);
+        if (success)
+            successfulCycles++;
+        else
+            failedCycles++;
+        totalConfidence += confidence;
+        return { result, confidence, verified };
+    }
+    function verifyThought(thought, context) {
+        return verificationEngine.verifyStep(thought, context);
+    }
+    function estimateConfidence(thought) {
+        const verification = verifyThought(thought);
+        return verification.confidence;
+    }
+    function knowWhenYouDontKnow(thought) {
+        const confidence = estimateConfidence(thought);
+        if (confidence < 0.5) {
+            return {
+                knows: false,
+                confidence,
+                reason: 'Low verification confidence - uncertainty detected',
+            };
+        }
+        // Check for hedge words that indicate uncertainty
+        const hedgeWords = ['可能', '也许', '不确定', '大概', 'perhaps', 'maybe', 'uncertain'];
+        const hasHedges = hedgeWords.some(h => thought.toLowerCase().includes(h));
+        if (hasHedges && confidence < 0.7) {
+            return {
+                knows: false,
+                confidence,
+                reason: 'Hedge words detected with moderate uncertainty',
+            };
+        }
+        return {
+            knows: true,
+            confidence,
+            reason: 'Verification passed with acceptable confidence',
+        };
+    }
+    function shouldSwitchStrategy(metrics) {
+        const currentPerf = metrics.strategyPerformance.get(currentStrategy);
+        return currentPerf.successRate < STRATEGY_SWITCH_THRESHOLD;
+    }
+    function selectBestStrategy(metrics) {
+        const alternatives = strategies.filter(s => s !== currentStrategy);
+        let bestStrategy = currentStrategy;
+        let bestScore = 0;
+        for (const strategy of alternatives) {
+            const perf = metrics.strategyPerformance.get(strategy);
+            // Score = success rate weighted by confidence
+            const score = perf.successRate * perf.avgConfidence;
+            if (score > bestScore) {
+                bestScore = score;
+                bestStrategy = strategy;
+            }
+        }
+        const bestPerf = metrics.strategyPerformance.get(bestStrategy);
+        return {
+            strategy: bestStrategy,
+            confidence: bestPerf.avgConfidence,
+            reason: `Best performing strategy based on success rate (${bestPerf.successRate.toFixed(2)}) and confidence`,
+            alternatives,
+        };
+    }
+    function learnFromExperience(task, strategy, success, feedback) {
+        metaLearningHistory.push({
+            task: task.slice(0, 100),
+            strategy,
+            success,
+            feedback,
+            timestamp: Date.now(),
+        });
+        // Keep only last 100 entries
+        if (metaLearningHistory.length > 100) {
+            metaLearningHistory.shift();
+        }
+    }
+    function getMetaLearnedStrategies() {
+        const counts = new Map();
+        for (const entry of metaLearningHistory) {
+            if (entry.success) {
+                counts.set(entry.strategy, (counts.get(entry.strategy) || 0) + 1);
+            }
+        }
+        return counts;
+    }
+    function getMetrics() {
+        return {
+            totalReasoningCycles,
+            successfulCycles,
+            failedCycles,
+            strategySwitches,
+            selfCorrections,
+            averageConfidence: totalReasoningCycles > 0 ? totalConfidence / totalReasoningCycles : 0,
+            currentStrategy,
+            strategyPerformance: new Map(strategyPerformance),
+        };
+    }
+    function getStrategyPerformance(strategy) {
+        return strategyPerformance.get(strategy);
+    }
+    return {
+        monitor,
+        evaluate,
+        regulate,
+        plan,
+        executeWithStrategy,
+        verifyThought,
+        estimateConfidence,
+        knowWhenYouDontKnow,
+        shouldSwitchStrategy,
+        selectBestStrategy,
+        learnFromExperience,
+        getMetaLearnedStrategies,
+        getMetrics,
+        getStrategyPerformance,
+    };
+}

package/dist/core/cognition/react.js

@@ -0,0 +1,177 @@
+/**
+ * ReAct - Reasoning and Acting Integration
+ *
+ * Paper: "ReAct: Synergizing Reasoning and Acting in Language Models"
+ * Concept: Thought-Observation-Action cycle for self-correcting reasoning
+ *
+ * Key mechanisms:
+ * - Reasoning (Thought): Why am I doing this?
+ * - Observation: What happened when I did it?
+ * - Action: What should I do next?
+ * - Self-correction based on observations
+ */
+/**
+ * Create a ReAct engine for self-correcting reasoning
+ *
+ * The ReAct cycle:
+ * 1. Thought: Why am I doing this?
+ * 2. Action: What should I do?
+ * 3. Observation: What happened?
+ * 4. Evaluate: Did this help? If not, correct.
+ */
+export function createReActEngine() {
+    let totalRuns = 0;
+    let totalCorrections = 0;
+    let successfulRuns = 0;
+    async function reason(context) {
+        totalRuns++;
+        const steps = [];
+        let corrections = 0;
+        let currentGoal = context.goal;
+        let success = false;
+        let finalAnswer = '';
+        for (let stepNum = 1; stepNum <= context.maxSteps; stepNum++) {
+            // Step 1: Thought - analyze the situation
+            const thought = think(currentGoal, stepNum);
+            // Step 2: Action - decide what to do
+            const action = selectAction(currentGoal, steps);
+            // Step 3: Execute and observe
+            const result = await act(action);
+            const observation = observe(action, result);
+            // Step 4: Evaluate
+            const isCorrect = evaluateStep(currentGoal, action, result, steps);
+            const reactStep = {
+                stepNumber: stepNum,
+                thought,
+                action,
+                observation,
+                isCorrect,
+                timestamp: Date.now(),
+            };
+            steps.push(reactStep);
+            // Self-correction if needed
+            if (!isCorrect && context.enableSelfCorrection) {
+                const correctedSteps = correct(steps, observation);
+                if (correctedSteps.length > steps.length) {
+                    corrections++;
+                    totalCorrections++;
+                }
+            }
+            // Check for success
+            if (checkSuccess(currentGoal, result)) {
+                success = true;
+                finalAnswer = result;
+                break;
+            }
+            // Adjust goal if needed
+            currentGoal = adjustGoal(currentGoal, result);
+        }
+        if (success) {
+            successfulRuns++;
+        }
+        return {
+            success,
+            steps,
+            finalAnswer: finalAnswer || 'Goal not achieved within max steps',
+            corrections,
+            confidence: steps.length > 0
+                ? (steps.filter(s => s.isCorrect).length / steps.length)
+                : 0,
+        };
+    }
+    function think(goal, step) {
+        // Analyze the goal and current state
+        return `[Step ${step}] Reasoning: ${goal}
+    - What is the current state?
+    - What actions are available?
+    - What is the most promising next step?
+    - What could go wrong?`;
+    }
+    async function act(action) {
+        // In a real implementation, this would execute the action
+        // For now, simulate execution
+        return `Executed: ${action}`;
+    }
+    function observe(action, result) {
+        // Analyze what happened
+        if (result.includes('Error') || result.includes('Failed')) {
+            return `Observation: Action failed - ${result}`;
+        }
+        if (result.includes('Executed')) {
+            return `Observation: Action succeeded - ${result}`;
+        }
+        return `Observation: ${result}`;
+    }
+    function selectAction(goal, steps) {
+        // Simple action selection based on goal
+        if (goal.toLowerCase().includes('search')) {
+            return 'search_memory';
+        }
+        if (goal.toLowerCase().includes('verify')) {
+            return 'check_consistency';
+        }
+        if (goal.toLowerCase().includes('learn')) {
+            return 'store_lesson';
+        }
+        return 'analyze_and_decide';
+    }
+    function evaluateStep(goal, action, result, steps) {
+        // Check if this step helped achieve the goal
+        const goalKeywords = goal.toLowerCase().split(/\s+/);
+        const resultLower = result.toLowerCase();
+        // Simple evaluation: did we make progress?
+        const progressIndicators = ['success', 'completed', 'achieved', 'found', 'verified'];
+        const hasProgress = progressIndicators.some(ind => resultLower.includes(ind));
+        return hasProgress;
+    }
+    function checkSuccess(goal, result) {
+        const resultLower = result.toLowerCase();
+        const successIndicators = ['success', 'completed', 'achieved', 'found', 'verified', 'done'];
+        for (const indicator of successIndicators) {
+            if (resultLower.includes(indicator)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function adjustGoal(goal, result) {
+        // Adjust goal based on what happened
+        if (result.includes('failed') || result.includes('error')) {
+            return `retry: ${goal}`;
+        }
+        return goal;
+    }
+    function correct(steps, error) {
+        // Self-correction mechanism
+        totalCorrections++;
+        const lastStep = steps[steps.length - 1];
+        if (lastStep) {
+            // Add correction step
+            const correctionStep = {
+                stepNumber: steps.length + 1,
+                thought: `Self-correction: Previous step failed. ${error}`,
+                action: 'adjust_approach',
+                observation: 'Re-evaluating with new information',
+                isCorrect: true,
+                timestamp: Date.now(),
+            };
+            return [...steps, correctionStep];
+        }
+        return steps;
+    }
+    function getStats() {
+        return {
+            totalRuns,
+            corrections: totalCorrections,
+            successRate: totalRuns > 0 ? successfulRuns / totalRuns : 0,
+        };
+    }
+    return {
+        reason,
+        think,
+        act,
+        observe,
+        correct,
+        getStats,
+    };
+}

package/dist/core/cognition/retrieval-anchor.js

@@ -0,0 +1,99 @@
+/**
+ * Retrieval Anchor - Context-Augmented Reasoning
+ *
+ * Based on paper: LLM Cognitive Architecture (2025)
+ * Uses relevant documents/memories as anchors for reasoning.
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Create a retrieval anchor engine
+ * Uses semantic similarity for anchor selection
+ */
+export function createRetrievalAnchorEngine() {
+    const anchors = new Map();
+    /**
+     * Simple keyword-based relevance scoring
+     * In production, would use embeddings
+     */
+    function computeRelevance(query, content) {
+        const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+        const contentLower = content.toLowerCase();
+        if (queryWords.length === 0)
+            return 0.5;
+        let matches = 0;
+        for (const word of queryWords) {
+            if (contentLower.includes(word)) {
+                matches++;
+            }
+        }
+        return matches / queryWords.length;
+    }
+    function addAnchor(content, source, relevance = 0.8) {
+        const anchor = {
+            id: `anchor-${Date.now()}-${randomUUID().slice(0, 8)}`,
+            content,
+            source,
+            relevance,
+            recency: 1.0,
+            reliability: 0.8,
+            usedInReasoning: false,
+            createdAt: Date.now(),
+        };
+        anchors.set(anchor.id, anchor);
+        return anchor;
+    }
+    function query(q) {
+        const results = [];
+        const maxAnchors = q.maxAnchors ?? 5;
+        const minRelevance = q.minRelevance ?? 0.3;
+        for (const anchor of anchors.values()) {
+            const relevance = computeRelevance(q.query, anchor.content);
+            if (relevance >= minRelevance) {
+                results.push({ ...anchor, relevance });
+            }
+        }
+        // Sort by relevance, then recency if preferred
+        results.sort((a, b) => {
+            const relevanceDiff = b.relevance - a.relevance;
+            if (q.preferRecent && Math.abs(relevanceDiff) < 0.1) {
+                return b.createdAt - a.createdAt;
+            }
+            return relevanceDiff;
+        });
+        return results.slice(0, maxAnchors);
+    }
+    function selectAnchor(q) {
+        const results = query({ query: q, maxAnchors: 1, minRelevance: 0.4 });
+        return results[0] ?? null;
+    }
+    function markUsed(anchorId) {
+        const anchor = anchors.get(anchorId);
+        if (anchor) {
+            anchor.usedInReasoning = true;
+        }
+    }
+    function getStats() {
+        let used = 0;
+        let unused = 0;
+        for (const anchor of anchors.values()) {
+            if (anchor.usedInReasoning) {
+                used++;
+            }
+            else {
+                unused++;
+            }
+        }
+        return {
+            total: anchors.size,
+            used,
+            unused,
+        };
+    }
+    return {
+        addAnchor,
+        query,
+        selectAnchor,
+        markUsed,
+        getStats,
+    };
+}