dist_agent_lang 1.0.24

Agentic programming with library and CLI support for Off/On-chain network integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Test file to demonstrate admin and cloudadmin trust validation
// This shows how @trust, @web, @ai, and @chain attributes work together

@trust("centralized")
@web
@ai
@chain("ethereum")
service CentralizedService {
    // In centralized trust, all operations are allowed
    fn test_admin_operations() -> bool {
        // These should all succeed in centralized trust
        let kill_result = admin::kill("process_123", "resource_violation");
        let auth_result = cloudadmin::authorize("admin", "write", "database");
        let web_result = web::create_server(3000);
        let ai_result = ai::spawn_agent("data_processor");
        let chain_result = chain::deploy(1, "MyContract", {});
        
        log::info("test", "Centralized service - all operations allowed");
        return true;
    }
}

@trust("hybrid")
@web
@ai
@chain("ethereum")
service HybridService {
    // In hybrid trust, operations require specific privileges
    fn test_hybrid_operations() -> bool {
        // Web, AI, and Chain operations should work (have @web, @ai, @chain)
        let web_result = web::create_server(3000);
        let ai_result = ai::spawn_agent("data_processor");
        let chain_result = chain::deploy(1, "MyContract", {});
        
        // Admin operations should fail (no @admin attribute)
        // cloudadmin operations should fail (no @cloudadmin attribute)
        
        log::info("test", "Hybrid service - web/ai/chain allowed, admin/cloudadmin restricted");
        return true;
    }
}

@trust("decentralized")
@web
@ai
@chain("ethereum")
service DecentralizedService {
    // In decentralized trust, admin operations are completely restricted
    fn test_decentralized_operations() -> bool {
        // Web, AI, and Chain operations should work (have @web, @ai, @chain)
        let web_result = web::create_server(3000);
        let ai_result = ai::spawn_agent("data_processor");
        let chain_result = chain::deploy(1, "MyContract", {});
        
        // Admin and cloudadmin operations should fail (decentralized trust)
        
        log::info("test", "Decentralized service - web/ai/chain allowed, admin/cloudadmin forbidden");
        return true;
    }
}

@trust("hybrid")
@admin
@cloudadmin
@web
@ai
@chain("ethereum")
service HybridAdminService {
    // In hybrid trust with admin privileges, all operations should work
    fn test_hybrid_admin_operations() -> bool {
        // All operations should work (have admin/cloudadmin privileges)
        let kill_result = admin::kill("process_123", "resource_violation");
        let auth_result = cloudadmin::authorize("admin", "write", "database");
        let web_result = web::create_server(3000);
        let ai_result = ai::spawn_agent("data_processor");
        let chain_result = chain::deploy(1, "MyContract", {});
        
        log::info("test", "Hybrid admin service - all operations allowed");
        return true;
    }
}

// Test runner service
@trust("hybrid")
service TrustValidationTest {
    fn run_all_tests() -> bool {
        log::info("test", "=== Testing Trust Validation System ===");
        
        // Test centralized service
        log::info("test", "Testing CentralizedService...");
        let centralized = CentralizedService::test_admin_operations();
        
        // Test hybrid service (no admin privileges)
        log::info("test", "Testing HybridService...");
        let hybrid = HybridService::test_hybrid_operations();
        
        // Test decentralized service
        log::info("test", "Testing DecentralizedService...");
        let decentralized = DecentralizedService::test_decentralized_operations();
        
        // Test hybrid service with admin privileges
        log::info("test", "Testing HybridAdminService...");
        let hybrid_admin = HybridAdminService::test_hybrid_admin_operations();
        
        log::info("test", "=== Trust Validation Tests Complete ===");
        return centralized && hybrid && decentralized && hybrid_admin;
    }
    
    fn test_trust_models() -> map<string, any> {
        let results = {
            "centralized": {
                "admin_allowed": true,
                "cloudadmin_allowed": true,
                "web_allowed": true,
                "ai_allowed": true,
                "chain_allowed": true
            },
            "hybrid": {
                "admin_allowed": false,  // Unless @admin attribute present
                "cloudadmin_allowed": false,  // Unless @cloudadmin attribute present
                "web_allowed": true,  // If @web attribute present
                "ai_allowed": true,  // If @ai attribute present
                "chain_allowed": true  // If @chain attribute present
            },
            "decentralized": {
                "admin_allowed": false,
                "cloudadmin_allowed": false,
                "web_allowed": true,  // If @web attribute present
                "ai_allowed": true,  // If @ai attribute present
                "chain_allowed": true  // If @chain attribute present
            }
        };
        
        log::info("test", "Trust model permissions: " + results);
        return results;
    }
}