liminal-cli 0.3.1

The liminal command: serve the network, maintain its stores, or serve its discovery MCP over stdio
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

//! SDK-017 R4: each reply feeds the next request; a failed step stops the
//! flow by index; a missing pointer stops before sending; the first step
//! may not name a previous reply; too many steps are refused.

use serde_json::json;

use super::{fill, flow};
use crate::network::fake::{Answer, Fake};

fn rail() -> Fake {
    Fake::new(
        json!({}),
        &[
            (
                "embed.request",
                Answer::Reply(json!({ "vector": [1, 2, 3] })),
            ),
            ("store.request", Answer::Echo),
        ],
    )
}

#[test]
fn flow_feeds_each_reply_into_the_next_request() {
    let rail = rail();
    let answer = flow(
        &rail,
        &[
            json!({ "subject": "embed.request", "input": { "text": "a" } }),
            json!({ "subject": "store.request", "input": { "vector": { "$prev": "/vector" } } }),
        ],
    );
    assert!(!answer.is_error, "{:?}", answer.structured);
    assert_eq!(
        rail.pushed(),
        vec![
            ("embed.request".to_owned(), json!({ "text": "a" })),
            ("store.request".to_owned(), json!({ "vector": [1, 2, 3] })),
        ]
    );
    assert_eq!(
        answer.structured["steps"][1]["reply"],
        json!({ "echoed": { "vector": [1, 2, 3] } })
    );
}

#[test]
fn a_failed_step_stops_the_flow_by_index() {
    let rail = rail();
    let answer = flow(
        &rail,
        &[
            json!({ "subject": "embed.request", "input": {} }),
            json!({ "subject": "nobody.request", "input": {} }),
            json!({ "subject": "store.request", "input": {} }),
        ],
    );
    assert!(answer.is_error);
    assert_eq!(
        answer.structured["error"],
        "step 1 stopped the flow: nobody.request: no station serves nobody.request"
    );
    assert_eq!(answer.structured["failed_step"], 1);
    assert_eq!(answer.structured["steps"].as_array().map(Vec::len), Some(1));
    assert_eq!(rail.pushed().len(), 1);
}

#[test]
fn a_missing_pointer_stops_before_sending() {
    let rail = rail();
    let answer = flow(
        &rail,
        &[
            json!({ "subject": "embed.request", "input": {} }),
            json!({ "subject": "store.request", "input": { "v": { "$prev": "/nothing" } } }),
        ],
    );
    assert!(answer.is_error);
    assert_eq!(
        answer.structured["error"],
        "step 1 stopped the flow: $prev \"/nothing\" names nothing in the previous reply"
    );
    assert_eq!(rail.pushed().len(), 1);
}

#[test]
fn flow_refuses_prev_in_the_first_step_and_too_many_steps() {
    let rail = rail();
    let answer = flow(
        &rail,
        &[json!({ "subject": "embed.request", "input": { "$prev": "" } })],
    );
    assert!(answer.is_error);
    assert_eq!(
        answer.structured["error"],
        "step 0 stopped the flow: $prev \"\" in the first step"
    );
    let step = json!({ "subject": "embed.request", "input": {} });
    let answer = flow(
        &rail,
        &[step.clone(), step.clone(), step.clone(), step.clone(), step],
    );
    assert!(answer.is_error);
    assert_eq!(
        answer.structured["error"],
        "the flow has 5 steps, over the limit of 4"
    );
    assert_eq!(rail.pushed().len(), 0);
}

#[test]
fn fill_replaces_pointers_anywhere_and_keeps_the_rest() -> Result<(), String> {
    let prev = json!({ "a": { "b": [10, 20] }, "whole": true });
    let filled = fill(
        &json!({ "x": { "$prev": "/a/b/1" }, "y": [{ "$prev": "" }, 3], "z": "text" }),
        Some(&prev),
    )?;
    assert_eq!(filled, json!({ "x": 20, "y": [prev, 3], "z": "text" }));
    Ok(())
}