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

use super::{HeldWords, text};
use crate::mcp::negotiate::Era;
use crate::mcp::tools::ToolResult;
use serde_json::json;
use std::num::NonZeroUsize;

type TestResult = Result<(), Box<dyn std::error::Error>>;

#[test]
fn held_words_are_successful_and_unchanged_in_both_eras() -> TestResult {
    let held = HeldWords::new(
        "draft-1",
        "propose template: α\nsecond line",
        bound()?,
        bound()?,
    )?;
    for era in [Era::Legacy, Era::Modern] {
        let result = held.tool_result().into_result(era);
        assert_eq!(result["isError"], false);
        assert_eq!(
            result["structuredContent"],
            json!({
                "draft":"draft-1", "words":"propose template: α\nsecond line"
            })
        );
        assert_eq!(
            result["content"][0]["text"],
            "held by draft draft-1: propose template: α\nsecond line"
        );
    }
    assert!(!format!("{held:?}").contains("second line"));
    assert!(!format!("{:?}", held.tool_result()).contains("second line"));
    Ok(())
}

#[test]
fn ordinary_results_and_refusals_are_not_reinterpreted_as_held() {
    for result in [
        ToolResult::ok(json!({"words":"prepared"})),
        ToolResult::failed("refused", json!({"draft":"draft-1","words":"prepared"})),
    ] {
        assert_eq!(text(&result), None);
    }
}

#[test]
fn held_boundary_refuses_missing_ids_and_oversized_utf8() -> TestResult {
    let one = NonZeroUsize::MIN;
    assert!(HeldWords::new("", "prepared", bound()?, bound()?).is_err());
    assert!(HeldWords::new("draft\n1", "prepared", bound()?, bound()?).is_err());
    assert!(HeldWords::new("draft-1", "é", bound()?, one).is_err());
    Ok(())
}

fn bound() -> Result<NonZeroUsize, Box<dyn std::error::Error>> {
    NonZeroUsize::new(1024).ok_or_else(|| "test bound is zero".into())
}

#[test]
fn native_held_site_pair_is_recognized_without_a_state_tag() -> TestResult {
    assert!(
        super::from_wire(
            &json!({"state":"held","isError":true,"draft":"native-draft","words":"words"}),
            bound()?,
            bound()?
        )
        .is_err()
    );
    let answer = json!({"draft":"native-draft", "words":"the exact native words"});
    let held =
        super::from_wire(&answer, bound()?, bound()?)?.ok_or("native held pair was discarded")?;
    assert_eq!(
        text(&held).as_deref(),
        Some("held by draft native-draft: the exact native words")
    );
    assert!(!held.is_error);
    assert!(
        super::from_wire(
            &json!({"state":"refused","draft":"native-draft","words":"words"}),
            bound()?,
            bound()?
        )?
        .is_none()
    );
    Ok(())
}