mark-improving-agent 2.2.0

package/dist/core/cognition/active-inference.js

@@ -0,0 +1,296 @@
+/**
+ * Active Inference Engine
+ *
+ * Paper: "Active Inference in Multi-LLM Communication" (2024)
+ *
+ * Based on free energy principle:
+ * - Agents minimize free energy (surprise + complexity)
+ * - Active inference: choose actions that minimize expected surprise
+ * - Generative models: predict observations before they happen
+ * - Precision weighting: attention to salient information
+ *
+ * Key concepts:
+ * - Preference precision: How much an agent trusts its preferences
+ * - Policy selection: Choose actions that minimize expected free energy
+ * - Active inference loop: Infer → Act → Observe → Infer
+ */
+import { randomUUID } from 'crypto';
+const DEFAULT_CONFIG = {
+    explorationRate: 0.3,
+    precisionThreshold: 0.5,
+    surpriseThreshold: 2.0,
+    planningDepth: 3,
+    learningRate: 0.1,
+};
+const DEFAULT_PRIOR = {
+    active: 0.5,
+    expected: 0.5,
+    precision: 0.5,
+    entropy: 0.693, // ln(2)
+};
+export function createActiveInferenceEngine(config) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    let stats = {
+        totalInferences: 0,
+        successfulActions: 0,
+        failedActions: 0,
+        avgSurprise: 0,
+        avgComplexity: 0,
+        policiesGenerated: 0,
+        beliefsUpdated: 0,
+    };
+    // Policy history for learning
+    const policyHistory = [];
+    // Belief history
+    const beliefHistory = [];
+    function calculateSurprise(probability) {
+        if (probability <= 0)
+            return 100;
+        return -Math.log2(probability);
+    }
+    function calculateComplexity(prior, posterior) {
+        if (prior <= 0 || posterior <= 0)
+            return 0;
+        // KL divergence from prior to posterior
+        if (prior === 0 || posterior === 0)
+            return 0;
+        return posterior * Math.log2(posterior / prior);
+    }
+    function calculateAccuracy(observation, expectation) {
+        return 1 - Math.abs(observation - expectation);
+    }
+    function calculateFreeEnergy(observation, expectation, precision) {
+        // Convert observation to numeric value (simplified)
+        const obsValue = observation.length > 0 ? (observation.charCodeAt(0) % 100) / 100 : 0.5;
+        const probability = Math.max(0.01, Math.min(0.99, obsValue));
+        const surprise = calculateSurprise(probability);
+        const complexity = calculateComplexity(expectation, obsValue);
+        const accuracy = calculateAccuracy(obsValue, expectation);
+        const total = surprise + complexity * precision;
+        // Update running stats
+        stats.avgSurprise = (stats.avgSurprise * stats.totalInferences + surprise) / (stats.totalInferences + 1);
+        stats.avgComplexity = (stats.avgComplexity * stats.totalInferences + complexity) / (stats.totalInferences + 1);
+        return { surprise, complexity, accuracy, total };
+    }
+    function infer(observation, prior) {
+        stats.totalInferences++;
+        const belief = prior || { ...DEFAULT_PRIOR };
+        // Update belief based on observation
+        const obsValue = observation.length > 0 ? (observation.charCodeAt(0) % 100) / 100 : 0.5;
+        // Bayesian update: blend prior with observation
+        const newActive = belief.active * (1 - cfg.learningRate) + obsValue * cfg.learningRate;
+        const newPrecision = belief.precision * 0.95 + (1 - Math.abs(newActive - obsValue)) * 0.05;
+        const newBelief = {
+            active: newActive,
+            expected: belief.expected,
+            precision: Math.max(0.1, Math.min(1, newPrecision)),
+            entropy: getBeliefEntropy({ ...belief, active: newActive, precision: newPrecision }),
+        };
+        beliefHistory.push(newBelief);
+        if (beliefHistory.length > 50)
+            beliefHistory.shift();
+        return newBelief;
+    }
+    function generatePolicies(context, numPolicies = 5) {
+        const policies = [];
+        const contextLower = context.toLowerCase();
+        // Policy templates
+        const policyTemplates = [
+            { desc: 'explore', steps: ['search', 'analyze', 'plan'] },
+            { desc: 'exploit', steps: ['use_known', 'execute', 'verify'] },
+            { desc: 'replan', steps: ['observe', 'rethink', 'execute'] },
+            { desc: 'conservative', steps: ['validate', 'slow_execute', 'check'] },
+            { desc: 'adaptive', steps: ['observe', 'adapt', 'act'] },
+        ];
+        for (let i = 0; i < Math.min(numPolicies, policyTemplates.length); i++) {
+            const template = policyTemplates[i];
+            // Calculate expected free energy based on context
+            let expectedFE = 1.0;
+            if (contextLower.includes('uncertain') || contextLower.includes('unknown')) {
+                expectedFE += 0.5; // Higher FE for uncertain contexts
+            }
+            if (contextLower.includes('urgent') || contextLower.includes('quick')) {
+                expectedFE += 0.3; // Higher FE for urgent contexts
+            }
+            if (contextLower.includes('safe') || contextLower.includes('secure')) {
+                expectedFE -= 0.3; // Lower FE for safe contexts
+            }
+            // Add some randomness for diversity
+            const noise = (Math.random() - 0.5) * 0.4;
+            expectedFE = Math.max(0.1, expectedFE + noise);
+            // Calculate probability (softmax of negative FE)
+            const probability = Math.exp(-expectedFE) / (Math.exp(-0.5) + Math.exp(-expectedFE));
+            const policy = {
+                id: randomUUID(),
+                description: template.desc,
+                expectedFreeEnergy: expectedFE,
+                probability,
+                sequence: template.steps,
+            };
+            policies.push(policy);
+        }
+        // Normalize probabilities
+        const totalProb = policies.reduce((sum, p) => sum + p.probability, 0);
+        for (const policy of policies) {
+            policy.probability /= totalProb;
+        }
+        stats.policiesGenerated += policies.length;
+        return policies;
+    }
+    function selectPolicy(policies) {
+        if (policies.length === 0) {
+            return {
+                id: 'default',
+                description: 'default',
+                expectedFreeEnergy: 1.0,
+                probability: 1.0,
+                sequence: ['observe', 'act'],
+            };
+        }
+        // Exploration vs exploitation
+        const random = Math.random();
+        if (random < cfg.explorationRate) {
+            // Explore: select random policy with probability weighting
+            const cumsum = [];
+            let sum = 0;
+            for (const p of policies) {
+                sum += p.probability;
+                cumsum.push(sum);
+            }
+            const r = Math.random() * sum;
+            for (let i = 0; i < policies.length; i++) {
+                if (r <= cumsum[i]) {
+                    return policies[i];
+                }
+            }
+        }
+        // Exploit: select best policy
+        return policies.reduce((best, p) => p.expectedFreeEnergy < best.expectedFreeEnergy ? p : best);
+    }
+    function updateBelief(current, observation, action) {
+        const obsValue = observation.length > 0 ? (observation.charCodeAt(0) % 100) / 100 : 0.5;
+        // Action effect on belief
+        let actionEffect = 0;
+        if (action.includes('explore'))
+            actionEffect = 0.1;
+        else if (action.includes('exploit'))
+            actionEffect = -0.05;
+        else if (action.includes('replan'))
+            actionEffect = 0.15;
+        const newActive = current.active + actionEffect * cfg.learningRate;
+        const newPrecision = updatePrecision(current, Math.abs(obsValue - current.active));
+        stats.beliefsUpdated++;
+        return {
+            active: Math.max(0, Math.min(1, newActive)),
+            expected: current.expected,
+            precision: Math.max(0.1, Math.min(1, newPrecision)),
+            entropy: getBeliefEntropy(current),
+        };
+    }
+    function updatePrecision(belief, surprise) {
+        // Precision increases when surprise is low, decreases when high
+        const targetPrecision = belief.precision - surprise * 0.1;
+        return Math.max(0.1, Math.min(1, targetPrecision));
+    }
+    function act(belief, context = '') {
+        const policies = generatePolicies(context);
+        const selectedPolicy = selectPolicy(policies);
+        // Get action from policy sequence
+        const action = selectedPolicy.sequence[0];
+        // Simulate observation
+        const newObservations = [`observed_${action}`, `context_${context.slice(0, 20)}`];
+        // Calculate free energy
+        const fe = calculateFreeEnergy(newObservations[0], belief.expected, belief.precision);
+        // Check if surprise exceeds threshold
+        if (fe.surprise > cfg.surpriseThreshold) {
+            // Replan needed - generate new policies
+            const replanPolicies = generatePolicies(context + '_replan', 3);
+            const replanPolicy = selectPolicy(replanPolicies);
+            return {
+                selectedPolicy: replanPolicy,
+                beliefState: belief,
+                freeEnergy: fe,
+                action: replanPolicy.sequence[0],
+                newObservations,
+                timestamp: Date.now(),
+            };
+        }
+        return {
+            selectedPolicy,
+            beliefState: belief,
+            freeEnergy: fe,
+            action,
+            newObservations,
+            timestamp: Date.now(),
+        };
+    }
+    function learnFromOutcome(policy, success) {
+        policyHistory.push({ policy, success, timestamp: Date.now() });
+        if (policyHistory.length > 100)
+            policyHistory.shift();
+        if (success) {
+            stats.successfulActions++;
+            // Increase probability of similar policies
+            cfg.explorationRate = Math.max(0.1, cfg.explorationRate - 0.02);
+        }
+        else {
+            stats.failedActions++;
+            // Decrease exploration rate when failing
+            cfg.explorationRate = Math.min(0.9, cfg.explorationRate + 0.05);
+        }
+    }
+    function getBeliefEntropy(belief) {
+        if (belief.precision <= 0)
+            return 1;
+        // Entropy decreases with higher precision
+        return Math.log2(1 / belief.precision) * 0.5;
+    }
+    function calculatePrecisionWeighting(surprise) {
+        // Precision weighting is inverse of surprise
+        return Math.exp(-surprise);
+    }
+    function getConfig() {
+        return { ...cfg };
+    }
+    function updateConfig(newConfig) {
+        Object.assign(cfg, newConfig);
+    }
+    function getStats() {
+        return { ...stats };
+    }
+    return {
+        infer,
+        act,
+        calculateFreeEnergy,
+        generatePolicies,
+        selectPolicy,
+        updateBelief,
+        updatePrecision,
+        learnFromOutcome,
+        getConfig,
+        updateConfig,
+        getStats,
+        getBeliefEntropy,
+        calculatePrecisionWeighting,
+    };
+}
+// Helper to format free energy metrics
+export function formatFreeEnergyMetrics(fe) {
+    return `
+Free Energy Analysis:
+  Surprise: ${fe.surprise.toFixed(3)}
+  Complexity: ${fe.complexity.toFixed(3)}
+  Accuracy: ${fe.accuracy.toFixed(3)}
+  Total: ${fe.total.toFixed(3)}
+  `.trim();
+}
+// Helper to format belief state
+export function formatBeliefState(belief) {
+    return `
+Belief State:
+  Active: ${(belief.active * 100).toFixed(1)}%
+  Expected: ${(belief.expected * 100).toFixed(1)}%
+  Precision: ${(belief.precision * 100).toFixed(1)}%
+  Entropy: ${belief.entropy.toFixed(3)}
+  `.trim();
+}

package/dist/core/cognition/cognitive-architecture.js

@@ -0,0 +1,263 @@
+/**
+ * Cognitive Architecture for Language Agents (CoALA)
+ *
+ * Paper: "Cognitive Architectures for Language Agents" (Steeven
+ *
+ * Key components:
+ * - Memory (M): External storage + Working memory
+ * - Reasoning (R): In-Context learning, Plan execution, Chain-of-Thought
+ * - Action (A): Tool use, Generation
+ * - Perception (P): Input processing, Attention
+ *
+ * Plus:
+ * - Episodic Memory: Experience storage
+ * - Procedural Memory: Skills and policies
+ * - Long-term Memory: World knowledge
+ * - Metacognitive Monitoring: Self-awareness
+ */
+import { randomUUID } from 'crypto';
+// Re-export all cognitive components
+export * from './index.js';
+/**
+ * Create the full cognitive architecture based on CoALA
+ */
+export function createCognitiveArchitecture(name = 'HeartFlow-CoALA') {
+    const architecture = {
+        id: randomUUID(),
+        name,
+        memory: new Map(),
+        reasoning: new Map(),
+        action: new Map(),
+        perception: {
+            type: 'perception',
+            description: 'Input processing and attention mechanism',
+            enabled: true,
+            stats: { inputsProcessed: 0, attentionShifts: 0 },
+        },
+        metacognitive: {
+            type: 'metacognitive',
+            description: 'Self-awareness and monitoring',
+            enabled: true,
+            stats: { reflections: 0, corrections: 0 },
+        },
+    };
+    // Initialize memory components
+    const memoryComponents = [
+        'perception', 'working_memory', 'episodic', 'semantic', 'procedural'
+    ];
+    for (const comp of memoryComponents) {
+        architecture.memory.set(comp, {
+            type: comp,
+            description: `Memory component: ${comp}`,
+            enabled: true,
+            stats: { reads: 0, writes: 0 },
+        });
+    }
+    // Initialize reasoning components
+    const reasoningComponents = [
+        'llm', 'cot', 'plan_execution', 'in_context'
+    ];
+    for (const comp of reasoningComponents) {
+        architecture.reasoning.set(comp, {
+            type: comp,
+            description: `Reasoning component: ${comp}`,
+            enabled: true,
+            stats: { invocations: 0, successes: 0 },
+        });
+    }
+    // Initialize action components
+    const actionComponents = ['tool_use', 'generation', 'world_interaction'];
+    for (const comp of actionComponents) {
+        architecture.action.set(comp, {
+            type: comp,
+            description: `Action component: ${comp}`,
+            enabled: true,
+            stats: { invocations: 0, successes: 0 },
+        });
+    }
+    // Working memory (simulated)
+    let workingMemory = [];
+    // Stats
+    let stats = {
+        totalCycles: 0,
+        memoryAccesses: 0,
+        reasoningSteps: 0,
+        actionsTaken: 0,
+        metacognitiveFlags: 0,
+    };
+    function perceive(input) {
+        stats.totalCycles++;
+        architecture.perception.stats.inputsProcessed++;
+        // Simple attention mechanism - focus on key terms
+        const attention = new Map();
+        const words = input.split(/\s+/);
+        for (const word of words) {
+            if (word.length > 4) {
+                attention.set(word, Math.random() * 0.5 + 0.5);
+            }
+        }
+        return {
+            processed: input.toLowerCase().trim(),
+            attention,
+        };
+    }
+    function readMemory(query) {
+        stats.memoryAccesses++;
+        architecture.memory.get('working_memory').stats.reads++;
+        // Search in working memory
+        const results = workingMemory.filter(item => item.toLowerCase().includes(query.toLowerCase()));
+        return results;
+    }
+    function writeMemory(content, type) {
+        stats.memoryAccesses++;
+        const component = architecture.memory.get(type);
+        if (component) {
+            component.stats.writes++;
+        }
+        if (type === 'working_memory') {
+            workingMemory.push(content);
+            if (workingMemory.length > 100) {
+                workingMemory = workingMemory.slice(-100);
+            }
+        }
+    }
+    function updateWorkingMemory(items) {
+        workingMemory = items.slice(-100);
+        architecture.memory.get('working_memory').stats.writes++;
+    }
+    function reason(input, mode) {
+        stats.reasoningSteps++;
+        const component = architecture.reasoning.get(mode);
+        if (component) {
+            component.stats.invocations++;
+        }
+        let result = '';
+        let confidence = 0.7;
+        switch (mode) {
+            case 'llm':
+                result = `LLM reasoning on: ${input.slice(0, 50)}...`;
+                confidence = 0.8;
+                break;
+            case 'cot':
+                result = `Chain-of-thought: ${input.split('.').slice(0, 3).join('. ')}...`;
+                confidence = 0.75;
+                break;
+            case 'plan_execution':
+                result = `Executing plan: ${input.slice(0, 30)}...`;
+                confidence = 0.7;
+                break;
+            case 'in_context':
+                result = `In-context: ${input.slice(0, 30)}...`;
+                confidence = 0.65;
+                break;
+        }
+        if (component) {
+            component.stats.successes++;
+        }
+        return { result, confidence };
+    }
+    function act(action, tools) {
+        stats.actionsTaken++;
+        const component = architecture.action.get('tool_use');
+        if (component) {
+            component.stats.invocations++;
+        }
+        let success = true;
+        let result = '';
+        if (tools && tools.length > 0) {
+            result = `Used tools [${tools.join(', ')}] for: ${action.slice(0, 30)}...`;
+        }
+        else {
+            result = `Action: ${action.slice(0, 30)}...`;
+        }
+        if (component) {
+            component.stats.successes++;
+        }
+        return { result, success };
+    }
+    function monitor() {
+        const alerts = [];
+        if (stats.totalCycles > 100 && stats.memoryAccesses / stats.totalCycles < 0.1) {
+            alerts.push('Low memory access rate relative to cycles');
+        }
+        if (stats.reasoningSteps > 50 && stats.reasoningSteps / stats.totalCycles > 0.5) {
+            alerts.push('High reasoning overhead');
+        }
+        return { metrics: { ...stats }, alerts };
+    }
+    function reflect() {
+        architecture.metacognitive.stats.reflections++;
+        stats.metacognitiveFlags++;
+        const insights = [];
+        const improvements = [];
+        // Analyze usage patterns
+        const memStats = Array.from(architecture.memory.values()).map(v => v.stats);
+        const totalMemAccess = memStats.reduce((sum, s) => sum + s.reads + s.writes, 0);
+        if (totalMemAccess > 10) {
+            insights.push(`Memory accessed ${totalMemAccess} times`);
+        }
+        const reasoningStats = Array.from(architecture.reasoning.values()).map(v => v.stats);
+        const totalReasoning = reasoningStats.reduce((sum, s) => sum + s.invocations, 0);
+        if (totalReasoning > 10) {
+            insights.push(`Reasoning invoked ${totalReasoning} times`);
+        }
+        // Generate improvements
+        if (totalMemAccess < stats.totalCycles * 0.1) {
+            improvements.push('Increase memory usage - consider storing intermediate results');
+        }
+        if (stats.metacognitiveFlags > 5) {
+            improvements.push('High metacognitive overhead - consider streamlining monitoring');
+        }
+        return { insights, improvements };
+    }
+    function getArchitecture() {
+        return architecture;
+    }
+    function getStats() {
+        return { ...stats };
+    }
+    function getComponent(type) {
+        if (architecture.perception.type === type)
+            return architecture.perception;
+        if (architecture.metacognitive.type === type)
+            return architecture.metacognitive;
+        for (const comp of architecture.memory.values()) {
+            if (comp.type === type)
+                return comp;
+        }
+        for (const comp of architecture.reasoning.values()) {
+            if (comp.type === type)
+                return comp;
+        }
+        for (const comp of architecture.action.values()) {
+            if (comp.type === type)
+                return comp;
+        }
+        return undefined;
+    }
+    function enableComponent(type) {
+        const comp = getComponent(type);
+        if (comp)
+            comp.enabled = true;
+    }
+    function disableComponent(type) {
+        const comp = getComponent(type);
+        if (comp)
+            comp.enabled = false;
+    }
+    return {
+        getArchitecture,
+        getStats,
+        getComponent,
+        enableComponent,
+        disableComponent,
+        perceive,
+        readMemory,
+        writeMemory,
+        updateWorkingMemory,
+        reason,
+        act,
+        monitor,
+        reflect,
+    };
+}

package/dist/core/cognition/dual-process.js

@@ -0,0 +1,102 @@
+/**
+ * Dual Process Cognition - System 1 & System 2
+ *
+ * Based on paper: LLM Cognitive Architecture (2025)
+ * - System 1: Fast, intuitive, automatic thinking
+ * - System 2: Slow, deliberate, analytical reasoning
+ */
+export function createDualProcessCognition() {
+    let currentMode = 'system1';
+    let system1Count = 0;
+    let system2Count = 0;
+    let switches = 0;
+    const startTime = Date.now();
+    /**
+     * Decide whether to use System 1 or System 2 based on context
+     */
+    function shouldUseSystem2(ctx) {
+        // High complexity favors System 2
+        if (ctx.complexity > 0.7)
+            return true;
+        // High stakes (important decisions) favor System 2
+        if (ctx.stakes > 0.8)
+            return true;
+        // Low urgency with high complexity favors System 2
+        if (ctx.complexity > 0.4 && ctx.urgency < 0.5)
+            return true;
+        // Default to System 1 for routine decisions
+        return false;
+    }
+    /**
+     * System 1: Fast, intuitive thinking
+     */
+    function system1Think(context) {
+        const start = Date.now();
+        system1Count++;
+        return {
+            mode: 'system1',
+            reasoning: '[System 1] Quick intuition-based response. Pattern matching activated.',
+            confidence: 0.7,
+            timeSpent: Date.now() - start,
+            reflectionCount: 0,
+        };
+    }
+    /**
+     * System 2: Slow, deliberate reasoning
+     */
+    function system2Think(context) {
+        const start = Date.now();
+        system2Count++;
+        let reflectionCount = 0;
+        // Simulate multi-step reflection
+        const reasoning = `[System 2] Deliberate analysis initiated.
+    Step 1: Decomposing problem into components
+    Step 2: Evaluating constraints and context
+    Step 3: Considering alternatives (${3 + Math.floor(Math.random() * 3)} options)
+    Step 4: Risk assessment
+    Step 5: Synthesis and conclusion`;
+        reflectionCount = 5;
+        return {
+            mode: 'system2',
+            reasoning,
+            confidence: 0.9,
+            timeSpent: Date.now() - start,
+            reflectionCount,
+        };
+    }
+    function analyze(context) {
+        const useSystem2 = shouldUseSystem2(context);
+        if (useSystem2 && currentMode === 'system1') {
+            switchMode('system1', 'system2');
+        }
+        else if (!useSystem2 && currentMode === 'system2') {
+            switchMode('system2', 'system1');
+        }
+        return useSystem2 ? system2Think(context) : system1Think(context);
+    }
+    function switchMode(from, to) {
+        if (from !== to) {
+            switches++;
+            currentMode = to;
+        }
+    }
+    function getCurrentMode() {
+        return currentMode;
+    }
+    function getStats() {
+        const total = system1Count + system2Count;
+        return {
+            system1Count,
+            system2Count,
+            switches,
+            system1Ratio: total > 0 ? system1Count / total : 0,
+            system2Ratio: total > 0 ? system2Count / total : 0,
+        };
+    }
+    return {
+        analyze,
+        switchMode,
+        getCurrentMode,
+        getStats,
+    };
+}

package/dist/core/cognition/index.js

@@ -0,0 +1,13 @@
+export * from './dual-process.js';
+export * from './retrieval-anchor.js';
+export * from './react.js';
+export * from './self-verification.js';
+export * from './tool-augmented-llm.js';
+export * from './tool-execution-verifier.js';
+export * from './learning-from-failure.js';
+export * from './metacognition.js';
+export * from './thought-graph.js';
+export * from './self-evolution.js';
+export * from './cognitive-architecture.js';
+export * from './meta-agent.js';
+export * from './active-inference.js';