noos 0.4.1

Reliability layer for Rust LLM agents: scope drift, cost circuit breaks, and procedural correction memory as event-driven Decisions.
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

//! Integration tests — sync memory API usage from external consumer perspective.
//!
//! Validates that applications can:
//! 1. Create MemoryAtom instances via public types
//! 2. Call hybrid_recall on pre-loaded atoms (sync, no async runtime needed)
//! 3. Store atoms through the MemoryStore trait
//!
//! Noos memory is intentionally sync-retrievable: applications own async I/O
//! (loading from database/disk), Noos owns cognitive computation over loaded
//! atoms. This separation keeps CognitiveSession sync while supporting
//! persistent memory backends.

use noos::{
    hybrid_recall, ActivationSource, AtomSource, AtomType, InMemoryStore, MemoryAtom,
    MemoryStore, RecallOptions, Synapse, SynapseType,
};
use std::collections::HashMap;

fn make_atom(id: &str, content: &str, topics: Vec<String>) -> MemoryAtom {
    MemoryAtom {
        id: id.into(),
        content: content.into(),
        embedding: None,
        atom_type: AtomType::Episodic,
        source: AtomSource::default(),
        importance: 0.7,
        access_count: 0,
        last_accessed_at: 0.0,
        created_at: 0.0,
        topics,
        domain: None,
        consolidated_from: None,
        is_consolidated: false,
        parent_id: None,
        depth: None,
        label: None,
        child_ids: None,
        superseded: false,
        suppressed: false,
        dormant: false,
        tags: vec![],
        encoding_context: None,
        retrieval_reward: None,
        reconsolidation_count: None,
        arousal: None,
        valence: None,
        epoch: None,
        crystallized: false,
    }
}

#[test]
fn hybrid_recall_finds_topic_match() {
    // Application loads its atoms (sync in Noos; async I/O is app's concern).
    let atoms = vec![
        make_atom("a1", "Rust async basics", vec!["rust".into(), "async".into()]),
        make_atom("a2", "Python type hints", vec!["python".into(), "types".into()]),
        make_atom("a3", "Rust ownership rules", vec!["rust".into(), "ownership".into()]),
    ];
    let synapses = HashMap::new();

    let results = hybrid_recall(
        &atoms,
        None, // No query embedding — topic-only match
        "How does rust ownership work?",
        &synapses,
        &RecallOptions::default(),
    );

    // Rust-related atoms should activate.
    assert!(
        !results.is_empty(),
        "Topic-matching query should retrieve at least one atom"
    );
    assert!(
        results.iter().any(|a| a.atom.id == "a3"),
        "Ownership query should retrieve the ownership atom"
    );
}

#[test]
fn activation_sources_distinguish_retrieval_paths() {
    // Vector search vs graph spreading vs convergent — distinct enum values.
    // Just verify the enum is usable from outside.
    let v = ActivationSource::Vector;
    let g = ActivationSource::Graph;
    let c = ActivationSource::Convergent;
    assert_ne!(v, g);
    assert_ne!(g, c);
}

#[tokio::test]
async fn in_memory_store_round_trip() {
    // MemoryStore trait is async (applications providing persistent backends
    // will naturally be async); the default InMemoryStore works for tests
    // and lightweight in-process use.
    let mut store = InMemoryStore::new();

    let atom = make_atom("a1", "Test content", vec!["test".into()]);
    store.store_atom(atom.clone()).await.unwrap();

    let retrieved = store.get_atom("a1").await.unwrap();
    assert!(retrieved.is_some());
    assert_eq!(retrieved.unwrap().content, "Test content");

    // Synapses link atoms by ID.
    let atom2 = make_atom("a2", "Related", vec!["test".into()]);
    store.store_atom(atom2).await.unwrap();

    let syn = Synapse {
        id: "s1".into(),
        source: "a1".into(),
        target: "a2".into(),
        synapse_type: SynapseType::RelatesTo,
        strength: 0.6,
        created_at: 0.0,
        last_accessed_at: None,
        access_count: None,
    };
    store.store_synapse(syn).await.unwrap();

    let syns = store.get_synapses_for("a1").await.unwrap();
    assert_eq!(syns.len(), 1);
    assert_eq!(syns[0].target, "a2");

    assert_eq!(store.atom_count(), 2);
}

#[test]
fn recall_options_default_is_usable() {
    // Apps should be able to start with defaults and tweak.
    let mut opts = RecallOptions::default();
    assert_eq!(opts.top_k, 10);
    assert_eq!(opts.graph_depth, 2);

    // Override one field.
    opts.top_k = 5;
    assert_eq!(opts.top_k, 5);
}