mark-improving-agent 2.2.0

package/dist/core/cognition/tool-execution-verifier.js

@@ -0,0 +1,204 @@
+/**
+ * Tool Execution Verification - Pre/Post Execution Checks
+ *
+ * Paper: "AgentEscapeBench: Tool-Grounded Reasoning Failures"
+ * Key insight: 82.3% of errors are predictable and preventable
+ *
+ * Error patterns:
+ * - Tool selection errors (36.5%)
+ * - Parameter errors (30.1%)
+ * - Verification errors (15.6%)
+ * - Context length errors (10.2%)
+ * - Semantic errors (7.6%)
+ */
+const ERROR_PATTERNS = {
+    selection: [
+        { pattern: /tool.*not.*found|unknown.*tool/i, severity: 'critical' },
+        { pattern: /multiple.*tools.*similar|ambiguous.*tool/i, severity: 'high' },
+    ],
+    parameter: [
+        { pattern: /missing.*required|required.*param/i, severity: 'critical' },
+        { pattern: /invalid.*type|type.*mismatch/i, severity: 'high' },
+        { pattern: /empty.*param|missing.*value/i, severity: 'medium' },
+    ],
+    context: [
+        { pattern: /context.*exceed|max.*length/i, severity: 'high' },
+        { pattern: /truncat|overflow/i, severity: 'medium' },
+    ],
+    semantic: [
+        { pattern: /wrong.*tool|incorrect.*selection/i, severity: 'high' },
+        { pattern: /misunderstand.*query|wrong.*intent/i, severity: 'medium' },
+    ],
+};
+export function createToolExecutionVerifier() {
+    let totalExecutions = 0;
+    let failures = 0;
+    let selfCorrections = 0;
+    function preExecutionCheck(toolId, params) {
+        const checks = [];
+        // Check 1: Tool selection validity
+        if (!toolId || toolId.length < 3) {
+            checks.push({
+                type: 'selection',
+                passed: false,
+                issue: 'Invalid tool ID format',
+                suggestion: 'Ensure tool ID is a valid non-empty string',
+                severity: 'critical',
+            });
+        }
+        else {
+            checks.push({
+                type: 'selection',
+                passed: true,
+                severity: 'low',
+            });
+        }
+        // Check 2: Parameter completeness
+        const requiredParams = ['query', 'content', 'action'];
+        const hasRequired = requiredParams.some(p => p in params);
+        if (!hasRequired && Object.keys(params).length === 0) {
+            checks.push({
+                type: 'parameter',
+                passed: false,
+                issue: 'No parameters provided',
+                suggestion: 'Add at least one parameter (query, content, or action)',
+                severity: 'high',
+            });
+        }
+        else {
+            checks.push({
+                type: 'parameter',
+                passed: true,
+                severity: 'low',
+            });
+        }
+        // Check 3: Context length
+        const paramStr = JSON.stringify(params);
+        if (paramStr.length > 10000) {
+            checks.push({
+                type: 'context',
+                passed: false,
+                issue: 'Parameters exceed safe length',
+                suggestion: 'Reduce parameter size or split into multiple calls',
+                severity: 'high',
+            });
+        }
+        else {
+            checks.push({
+                type: 'context',
+                passed: true,
+                severity: 'low',
+            });
+        }
+        return checks;
+    }
+    function postExecutionCheck(output, expected) {
+        const checks = [];
+        // Check 1: Output validity
+        if (!output || output.length === 0) {
+            checks.push({
+                type: 'verification',
+                passed: false,
+                issue: 'Empty output received',
+                suggestion: 'Retry execution or check tool functionality',
+                severity: 'high',
+            });
+        }
+        else {
+            checks.push({
+                type: 'verification',
+                passed: true,
+                severity: 'low',
+            });
+        }
+        // Check 2: Error pattern detection
+        const outputLower = output.toLowerCase();
+        for (const [type, patterns] of Object.entries(ERROR_PATTERNS)) {
+            for (const { pattern, severity } of patterns) {
+                if (pattern.test(output)) {
+                    checks.push({
+                        type: type,
+                        passed: false,
+                        issue: `Error pattern detected: ${type}`,
+                        severity,
+                    });
+                }
+            }
+        }
+        // Check 3: Semantic match (if expected provided)
+        if (expected && output !== expected) {
+            const similarity = computeStringSimilarity(output, expected);
+            if (similarity < 0.5) {
+                checks.push({
+                    type: 'semantic',
+                    passed: false,
+                    issue: 'Output significantly differs from expectation',
+                    suggestion: 'Verify tool execution was correct',
+                    severity: 'medium',
+                });
+            }
+        }
+        return checks;
+    }
+    function computeStringSimilarity(a, b) {
+        const aWords = new Set(a.toLowerCase().split(/\s+/));
+        const bWords = new Set(b.toLowerCase().split(/\s+/));
+        let intersection = 0;
+        for (const word of aWords) {
+            if (bWords.has(word))
+                intersection++;
+        }
+        const union = aWords.size + bWords.size - intersection;
+        return union > 0 ? intersection / union : 1.0;
+    }
+    function verifyExecution(plan, result) {
+        totalExecutions++;
+        const postChecks = postExecutionCheck(result);
+        const failedChecks = postChecks.filter(c => !c.passed);
+        const criticalFailed = failedChecks.some(c => c.severity === 'critical');
+        if (criticalFailed || failedChecks.length > 2) {
+            failures++;
+        }
+        // Self-correction attempt
+        let selfCorrected = false;
+        if (failedChecks.length > 0 && failedChecks.length <= 2) {
+            selfCorrections++;
+            selfCorrected = true;
+        }
+        return {
+            success: failedChecks.length === 0,
+            output: result,
+            checks: postChecks,
+            error: criticalFailed ? 'Critical failure detected' : undefined,
+            duration: plan.estimatedDuration,
+            selfCorrected,
+        };
+    }
+    function predictFailure(toolId, params) {
+        const checks = preExecutionCheck(toolId, params);
+        const criticalFailed = checks.find(c => !c.passed && c.severity === 'critical');
+        if (criticalFailed) {
+            return {
+                willFail: true,
+                reason: criticalFailed.issue,
+            };
+        }
+        return { willFail: false };
+    }
+    function getStats() {
+        return {
+            totalExecutions,
+            failures,
+            selfCorrections,
+            failureRate: totalExecutions > 0 ? failures / totalExecutions : 0,
+            selfCorrectionRate: totalExecutions > 0 ? selfCorrections / totalExecutions : 0,
+        };
+    }
+    return {
+        preExecutionCheck,
+        postExecutionCheck,
+        verifyExecution,
+        predictFailure,
+        getStats,
+    };
+}

package/dist/core/collaboration/agentic-loop.js

@@ -0,0 +1,165 @@
+/**
+ * Agentic Loop - Think, Act, Observe Cycle
+ *
+ * Paper: "Critique Routing in Multi-Agent Collaboration" (2605.08631)
+ * Key insight: Even advanced models fail on simple tasks
+ * Critical: The Agentic Loop (Think → Act → Observe) is essential
+ *
+ * Key mechanisms:
+ * - Think: Analyze situation, plan action
+ * - Act: Execute the planned action
+ * - Observe: Check results, verify success
+ * - Loop until goal achieved or max iterations
+ */
+export function createAgenticLoop() {
+    let totalRuns = 0;
+    let successfulRuns = 0;
+    let totalIterations = 0;
+    const DEFAULT_CONFIG = {
+        maxIterations: 10,
+        enableSelfCorrection: true,
+        verifyEachStep: true,
+    };
+    async function run(goal, config) {
+        totalRuns++;
+        const cfg = { ...DEFAULT_CONFIG, ...config };
+        const steps = [];
+        let currentState = 'think';
+        let iterations = 0;
+        let totalDuration = 0;
+        let context = goal;
+        while (iterations < cfg.maxIterations) {
+            const stepStart = Date.now();
+            iterations++;
+            // STEP 1: THINK
+            const thought = think(context);
+            currentState = 'think';
+            let action = '';
+            let observation = '';
+            let success = false;
+            // STEP 2: ACT
+            if (currentState === 'think') {
+                action = selectAction(context, steps);
+                currentState = 'act';
+                const actionResult = await act(action);
+                totalDuration += Date.now() - stepStart;
+                // STEP 3: OBSERVE
+                const observeResult = observe(actionResult);
+                currentState = 'observe';
+                observation = observeResult.feedback;
+                success = observeResult.success;
+                steps.push({
+                    state: currentState,
+                    thought,
+                    action,
+                    observation,
+                    timestamp: Date.now(),
+                    duration: Date.now() - stepStart,
+                });
+                // Self-correction if needed
+                if (!success && cfg.enableSelfCorrection) {
+                    context = adjustContext(context, observation);
+                    continue;
+                }
+                // Check if complete
+                if (success && checkComplete(observation)) {
+                    currentState = 'complete';
+                    successfulRuns++;
+                    break;
+                }
+                // Update context for next iteration
+                context = updateContext(context, action, observation);
+            }
+        }
+        if (currentState !== 'complete') {
+            currentState = 'failed';
+        }
+        totalIterations += iterations;
+        const confidence = calculateConfidence(steps);
+        return {
+            success: currentState === 'complete',
+            steps,
+            iterations,
+            finalState: currentState,
+            confidence,
+            totalDuration,
+        };
+    }
+    function think(context) {
+        // Analyze situation and plan
+        return `[Think] Current goal: ${context}
+    - What is the current state?
+    - What actions are available?
+    - What is the most promising next step?
+    - How will I know if I succeeded?`;
+    }
+    async function act(action) {
+        // Execute action (simulated)
+        // In real implementation, this would execute the actual action
+        return `[Act] Executed: ${action}`;
+    }
+    function observe(result) {
+        // Evaluate result
+        const successIndicators = ['success', 'completed', 'achieved', 'found', 'verified', 'done'];
+        const failIndicators = ['error', 'failed', 'not found', 'cannot', 'unable'];
+        const resultLower = result.toLowerCase();
+        const isSuccess = successIndicators.some(ind => resultLower.includes(ind));
+        const isFailed = failIndicators.some(ind => resultLower.includes(ind));
+        return {
+            success: isSuccess && !isFailed,
+            feedback: result,
+        };
+    }
+    function selectAction(context, steps) {
+        // Action selection based on context
+        if (context.includes('search'))
+            return 'search_memory';
+        if (context.includes('verify'))
+            return 'check_consistency';
+        if (context.includes('learn'))
+            return 'store_lesson';
+        if (context.includes('analyze'))
+            return 'analyze_situation';
+        // Default action
+        return 'process_and_respond';
+    }
+    function shouldContinue(result, iterations) {
+        const successIndicators = ['success', 'completed', 'achieved'];
+        const resultLower = result.toLowerCase();
+        return !successIndicators.some(ind => resultLower.includes(ind)) && iterations < 10;
+    }
+    function checkComplete(observation) {
+        const successIndicators = ['success', 'completed', 'achieved', 'done', 'verified'];
+        const observationLower = observation.toLowerCase();
+        return successIndicators.some(ind => observationLower.includes(ind));
+    }
+    function updateContext(context, action, observation) {
+        // Update context for next iteration
+        return `Previous: ${action} -> ${observation}. Continuing with: ${context}`;
+    }
+    function adjustContext(context, feedback) {
+        // Self-correction: adjust approach based on feedback
+        return `Self-correcting. Feedback: ${feedback}. Original goal: ${context}`;
+    }
+    function calculateConfidence(steps) {
+        if (steps.length === 0)
+            return 0;
+        const successSteps = steps.filter(s => s.state === 'observe' && s.observation.includes('success'));
+        return successSteps.length / steps.length;
+    }
+    function getStats() {
+        return {
+            totalRuns,
+            successRate: totalRuns > 0 ? successfulRuns / totalRuns : 0,
+            avgIterations: totalRuns > 0 ? totalIterations / totalRuns : 0,
+        };
+    }
+    return {
+        run,
+        think,
+        act,
+        observe,
+        shouldContinue,
+        getStats,
+    };
+}

package/dist/core/collaboration/index.js

@@ -0,0 +1,3 @@
+export * from './multi-agent.js';
+export * from './agentic-loop.js';
+export * from './multi-agent-system.js';

package/dist/core/collaboration/multi-agent-system.js

@@ -0,0 +1,186 @@
+/**
+ * OpenHuman Integration - Agent System Patterns
+ *
+ * Based on tinyhumansai/openhuman multi-agent architecture
+ *
+ * Key concepts:
+ * - Architectobot: Project planning and task decomposition
+ * - Codecrusher: Implementation specialist
+ * - QualityQueen: Testing and verification
+ * - MemoryKeeper: Project memory maintenance
+ *
+ * Agent workflow:
+ * architectobot (plan) → user approval → codecrusher (implement) → architectobot (verify)
+ */
+import { randomUUID } from 'crypto';
+// Default agents matching OpenHuman's agent system
+const DEFAULT_OPENHUMAN_AGENTS = [
+    {
+        id: 'architectobot',
+        name: 'ArchitectoBot',
+        role: 'architect',
+        description: 'Project Architect & Task Breakdown Specialist',
+        color: 'blue',
+        model: 'claude-opus-4-6',
+        skills: ['codebase_analysis', 'documentation', 'task_decomposition', 'architecture_design'],
+        stats: { tasksCompleted: 0, successRate: 0.95, avgResponseTime: 5000 },
+    },
+    {
+        id: 'codecrusher',
+        name: 'CodeCrusher',
+        role: 'implementer',
+        description: 'Implementation specialist',
+        color: 'green',
+        model: 'claude-sonnet-4-6',
+        skills: ['typescript', 'rust', 'react', 'tauri', 'testing'],
+        stats: { tasksCompleted: 0, successRate: 0.92, avgResponseTime: 8000 },
+    },
+    {
+        id: 'qualityqueen',
+        name: 'QualityQueen',
+        role: 'reviewer',
+        description: 'Code quality guardian',
+        color: 'purple',
+        model: 'claude-sonnet-4-6',
+        skills: ['code_review', 'testing', 'coverage_analysis', 'linting'],
+        stats: { tasksCompleted: 0, successRate: 0.98, avgResponseTime: 3000 },
+    },
+    {
+        id: 'testmaster',
+        name: 'TestMaster',
+        role: 'tester',
+        description: 'Testing specialist',
+        color: 'orange',
+        model: 'claude-haiku-4-5',
+        skills: ['vitest', 'wdio', 'rust_tests', 'coverage'],
+        stats: { tasksCompleted: 0, successRate: 0.94, avgResponseTime: 4000 },
+    },
+    {
+        id: 'memorykeeper',
+        name: 'MemoryKeeper',
+        role: 'memory keeper',
+        description: 'Project memory specialist',
+        color: 'yellow',
+        model: 'claude-haiku-4-5',
+        skills: ['documentation', 'memory_management', 'context_keeping'],
+        stats: { tasksCompleted: 0, successRate: 0.99, avgResponseTime: 2000 },
+    },
+];
+export function createMultiAgentOrchestrator() {
+    const state = {
+        agents: new Map(DEFAULT_OPENHUMAN_AGENTS.map(a => [a.id, a])),
+        workflows: new Map(),
+        messages: [],
+    };
+    function registerAgent(agent) {
+        state.agents.set(agent.id, agent);
+    }
+    function getAgent(id) {
+        return state.agents.get(id);
+    }
+    function getAgentsByRole(role) {
+        return Array.from(state.agents.values()).filter(a => a.role === role);
+    }
+    function listAgents() {
+        return Array.from(state.agents.values());
+    }
+    function createWorkflow(name, task) {
+        const workflow = {
+            id: randomUUID(),
+            name,
+            task,
+            stages: [
+                { agent: 'architect', action: 'Analyze requirements and create implementation plan', status: 'pending' },
+                { agent: 'implementer', action: 'Implement code following the plan', status: 'pending' },
+                { agent: 'reviewer', action: 'Review code quality and architecture', status: 'pending' },
+                { agent: 'tester', action: 'Run tests and verify coverage', status: 'pending' },
+            ],
+            currentStage: 0,
+            createdAt: Date.now(),
+        };
+        state.workflows.set(workflow.id, workflow);
+        return workflow;
+    }
+    function advanceWorkflow(workflowId, result) {
+        const workflow = state.workflows.get(workflowId);
+        if (!workflow)
+            return;
+        const currentStage = workflow.stages[workflow.currentStage];
+        currentStage.status = 'done';
+        currentStage.result = result;
+        workflow.currentStage++;
+        if (workflow.currentStage >= workflow.stages.length) {
+            workflow.completedAt = Date.now();
+        }
+    }
+    function getWorkflowStatus(workflowId) {
+        return state.workflows.get(workflowId);
+    }
+    function sendMessage(message) {
+        const fullMessage = {
+            ...message,
+            id: randomUUID(),
+            timestamp: Date.now(),
+        };
+        state.messages.push(fullMessage);
+        return fullMessage;
+    }
+    function getMessages(agentId) {
+        return state.messages.filter(m => m.to === agentId || m.from === agentId);
+    }
+    async function executeWorkflow(workflowId) {
+        const workflow = state.workflows.get(workflowId);
+        if (!workflow) {
+            return { success: false, result: 'Workflow not found' };
+        }
+        const results = [];
+        for (let i = 0; i < workflow.stages.length; i++) {
+            const stage = workflow.stages[i];
+            stage.status = 'active';
+            workflow.currentStage = i;
+            const agents = getAgentsByRole(stage.agent);
+            if (agents.length > 0) {
+                const agent = agents[0];
+                agent.stats.tasksCompleted++;
+                stage.result = `[${agent.name}] completed: ${stage.action}`;
+                stage.status = 'done';
+                results.push(stage.result);
+            }
+        }
+        workflow.completedAt = Date.now();
+        return {
+            success: true,
+            result: results.join('\n'),
+        };
+    }
+    function getAgentStats(agentId) {
+        const agent = state.agents.get(agentId);
+        return agent ? { ...agent.stats } : { tasksCompleted: 0, successRate: 0, avgResponseTime: 0 };
+    }
+    return {
+        registerAgent,
+        getAgent,
+        getAgentsByRole,
+        listAgents,
+        createWorkflow,
+        advanceWorkflow,
+        getWorkflowStatus,
+        sendMessage,
+        getMessages,
+        executeWorkflow,
+        getAgentStats,
+    };
+}
+export function formatAgentStatus(agent) {
+    return `${agent.name}: [${agent.role}] | Tasks: ${agent.stats.tasksCompleted} | Success: ${(agent.stats.successRate * 100).toFixed(0)}%`;
+}
+export function formatWorkflowStatus(workflow) {
+    const stage = workflow.stages[workflow.currentStage];
+    const progress = `${workflow.currentStage + 1}/${workflow.stages.length}`;
+    return `
+Workflow: ${workflow.name}
+Progress: ${progress}
+Current: ${stage?.agent} - ${stage?.action}
+Status: ${workflow.completedAt ? '✅ Completed' : '🔄 In Progress'}
+  `.trim();
+}

package/dist/core/collaboration/multi-agent.js

@@ -0,0 +1,110 @@
+/**
+ * Multi-Agent Collaboration Protocol
+ *
+ * Paper: "ARMOR: Agentic Tool Reasoning" (2605.07103)
+ * Concept: Multi-agent collaboration with shared tool use
+ *
+ * Key mechanisms:
+ * - Agent communication protocol
+ * - Shared tool registry
+ * - Task decomposition and delegation
+ * - Result aggregation
+ */
+/**
+ * Create a multi-agent collaboration system
+ */
+export function createMultiAgentProtocol() {
+    const agents = new Map();
+    const messages = [];
+    const tasks = [];
+    function registerAgent(id, role, tools = []) {
+        const agent = {
+            id,
+            role,
+            tools,
+            messages: [],
+            tasks: [],
+            isActive: true,
+        };
+        agents.set(id, agent);
+        return agent;
+    }
+    function send(message) {
+        messages.push(message);
+        // Add to recipient's inbox
+        const recipient = agents.get(message.to);
+        if (recipient) {
+            recipient.messages.push(message);
+        }
+    }
+    function receive(from) {
+        const agent = agents.get(from);
+        if (!agent)
+            return [];
+        const unread = agent.messages.filter(m => m.to === from);
+        return unread;
+    }
+    function delegate(task) {
+        const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const delegatedTask = {
+            ...task,
+            id: taskId,
+            status: 'pending',
+        };
+        tasks.push(delegatedTask);
+        // Notify assigned agent
+        if (task.assignedTo) {
+            send({
+                from: 'system',
+                to: task.assignedTo,
+                type: 'request',
+                content: JSON.stringify(delegatedTask),
+                timestamp: Date.now(),
+            });
+        }
+        return taskId;
+    }
+    function aggregate(results) {
+        const completedTasks = results.filter(t => t.status === 'completed');
+        if (completedTasks.length === 0) {
+            return 'No results to aggregate';
+        }
+        // Simple aggregation: concatenate results
+        return completedTasks
+            .filter(t => t.result)
+            .map(t => `[${t.type}] ${t.result}`)
+            .join('\n');
+    }
+    function broadcast(content, exclude = []) {
+        for (const agent of agents.values()) {
+            if (!exclude.includes(agent.id)) {
+                send({
+                    from: 'system',
+                    to: agent.id,
+                    type: 'broadcast',
+                    content,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    function getStats() {
+        return {
+            messages: messages.length,
+            tasks: tasks.length,
+            agents: agents.size,
+        };
+    }
+    // Register default agents
+    registerAgent('planner', 'Task decomposition', ['analyze', 'decompose', 'plan']);
+    registerAgent('executor', 'Tool execution', ['execute', 'verify', 'correct']);
+    registerAgent('aggregator', 'Result synthesis', ['aggregate', 'summarize', 'validate']);
+    return {
+        send,
+        receive,
+        delegate,
+        aggregate,
+        broadcast,
+        getStats,
+    };
+}