cloudllm 0.15.9

A batteries-included Rust toolkit for building intelligent agents with LLM integration, multi-protocol tool support, multi-agent orchestration, and MentisDB-backed durable memory.
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
138
139
140
141
142
143
144
145
146

//! Documentation tests for Memory tool and MemoryProtocol
//!
//! These tests verify the examples in the documentation work correctly

use cloudllm::tool_protocol::ToolProtocol;
use cloudllm::tool_protocols::MemoryProtocol;
use cloudllm::tools::Memory;
use std::sync::Arc;

#[tokio::test]
async fn test_memory_basic_operations() {
    let memory = Memory::new();

    // Store data
    memory.put(
        "task_name".to_string(),
        "Document_Summary".to_string(),
        Some(3600),
    );

    // Retrieve data
    if let Some((value, metadata)) = memory.get("task_name", true) {
        assert_eq!(value, "Document_Summary");
        assert!(metadata.is_some());
        assert_eq!(metadata.unwrap().expires_in, Some(3600));
    } else {
        panic!("Expected to find task_name in memory");
    }

    // List all keys
    let keys = memory.list_keys();
    assert!(keys.contains(&"task_name".to_string()));

    // Delete key
    assert!(memory.delete("task_name"));

    // Clear all
    memory.clear();
    assert_eq!(memory.list_keys().len(), 0);
}

#[tokio::test]
async fn test_memory_tool_protocol_adapter() {
    let memory = Arc::new(Memory::new());
    let adapter = Arc::new(MemoryProtocol::new(memory));

    // Execute via adapter directly - Put operation
    let result = adapter
        .execute(
            "memory",
            serde_json::json!({"command": "P task_name Document_Summary 3600"}),
        )
        .await;

    assert!(result.is_ok(), "Put command should succeed");
    let result = result.unwrap();
    assert!(result.success);
}

#[tokio::test]
async fn test_memory_adapter_get_operation() {
    let memory = Arc::new(Memory::new());

    // Store directly in memory
    memory.put("key".to_string(), "value".to_string(), None);

    // Retrieve via adapter
    let adapter = Arc::new(MemoryProtocol::new(memory));

    let result = adapter
        .execute("memory", serde_json::json!({"command": "G key"}))
        .await;

    assert!(result.is_ok());
    let result = result.unwrap();
    assert!(result.success);
    assert_eq!(result.output["value"], "value");
}

#[tokio::test]
async fn test_memory_adapter_list_operation() {
    let memory = Arc::new(Memory::new());

    // Store multiple items
    memory.put("key1".to_string(), "value1".to_string(), None);
    memory.put("key2".to_string(), "value2".to_string(), None);

    let adapter = Arc::new(MemoryProtocol::new(memory));

    let result = adapter
        .execute("memory", serde_json::json!({"command": "L"}))
        .await;

    assert!(result.is_ok());
    let result = result.unwrap();
    assert!(result.success);

    let keys = result.output["keys"].as_array().unwrap();
    assert_eq!(keys.len(), 2);
}

#[tokio::test]
async fn test_memory_adapter_spec_command() {
    let memory = Arc::new(Memory::new());
    let adapter = Arc::new(MemoryProtocol::new(memory));

    let result = adapter
        .execute("memory", serde_json::json!({"command": "SPEC"}))
        .await;

    assert!(result.is_ok());
    let result = result.unwrap();
    assert!(result.success);

    let spec = result.output["specification"].as_str().unwrap();
    assert!(spec.contains("Memory tool quick-reference"));
    assert!(spec.contains("P <key> <value>"));
    assert!(spec.contains("G <key>"));
}

#[tokio::test]
async fn test_memory_adapter_with_ttl() {
    let memory = Arc::new(Memory::new());
    let adapter = Arc::new(MemoryProtocol::new(memory));

    // Store with TTL
    let result = adapter
        .execute(
            "memory",
            serde_json::json!({"command": "P temp_data temporary_value 60"}),
        )
        .await;

    assert!(result.is_ok());
    assert!(result.unwrap().success);

    // Verify it's there
    let result = adapter
        .execute("memory", serde_json::json!({"command": "G temp_data META"}))
        .await;

    assert!(result.is_ok());
    let result = result.unwrap();
    assert_eq!(result.output["value"], "temporary_value");
    assert_eq!(result.output["expires_in"], 60);
}