mcp-compressor-core 0.21.2

Internal Rust core for mcp-compressor. Prefer the public mcp-compressor crate.
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

mod common;

use mcp_compressor_core::compression::CompressionLevel;
use mcp_compressor_core::server::{
    BackendConfigSource, CompressedServer, CompressedServerConfig, ProxyTransformMode,
};
use serde_json::json;

#[tokio::test]
async fn compressed_tools_mode_exposes_wrappers_for_single_server() {
    let server = CompressedServer::connect_stdio(
        common::config(
            CompressionLevel::Max,
            Some("alpha"),
            ProxyTransformMode::CompressedTools,
            BackendConfigSource::Command,
        ),
        common::backend("alpha", "alpha_server.py"),
    )
    .await
    .unwrap();

    let names: Vec<String> = server
        .list_frontend_tools()
        .await
        .unwrap()
        .into_iter()
        .map(|tool| tool.name)
        .collect();
    assert_eq!(
        names,
        [
            "alpha_get_tool_schema",
            "alpha_invoke_tool",
            "alpha_list_tools"
        ]
    );
}

#[tokio::test]
async fn cli_mode_exposes_help_tool_and_keeps_exec_routing_available() {
    let server = CompressedServer::connect_stdio(
        common::config(
            CompressionLevel::Low,
            Some("alpha"),
            ProxyTransformMode::Cli,
            BackendConfigSource::Command,
        ),
        common::backend("alpha", "alpha_server.py"),
    )
    .await
    .unwrap();

    let tools = server.list_frontend_tools().await.unwrap();
    let names: Vec<String> = tools.iter().map(|tool| tool.name.clone()).collect();
    assert_eq!(names, ["alpha_help"]);
    assert!(tools[0]
        .description
        .as_deref()
        .unwrap_or_default()
        .contains("echo"));

    let result = server
        .invoke_tool("alpha_invoke_tool", "echo", json!({ "message": "hello" }))
        .await
        .unwrap();
    assert_eq!(result, "alpha:hello");
}

#[tokio::test]
async fn just_bash_mode_exposes_bash_tool_and_per_server_help_tools() {
    let server = CompressedServer::connect_multi_stdio(
        common::config(
            CompressionLevel::Low,
            None,
            ProxyTransformMode::JustBash,
            BackendConfigSource::Command,
        ),
        vec![
            common::backend("alpha", "alpha_server.py"),
            common::backend("beta", "beta_server.py"),
        ],
    )
    .await
    .unwrap();

    let tools = server.list_frontend_tools().await.unwrap();
    let names: Vec<String> = tools.iter().map(|tool| tool.name.clone()).collect();
    assert_eq!(names, ["bash_tool", "alpha_help", "beta_help"]);

    let bash_description = tools
        .iter()
        .find(|tool| tool.name == "bash_tool")
        .and_then(|tool| tool.description.as_deref())
        .unwrap_or_default();
    assert!(bash_description.contains("just-bash"));
    assert!(bash_description.contains("alpha"));
    assert!(bash_description.contains("language-hosted just-bash"));
    assert!(bash_description.contains("beta"));
    assert!(bash_description.contains("TOON"));

    let specs = server.just_bash_provider_specs();
    assert_eq!(specs.len(), 2);
    let alpha = specs
        .iter()
        .find(|spec| spec.provider_name == "alpha")
        .unwrap();
    assert_eq!(alpha.help_tool_name, "alpha_help");
    let echo = alpha
        .tools
        .iter()
        .find(|command| command.backend_tool_name == "echo")
        .unwrap();
    assert_eq!(echo.command_name, "echo");
    assert_eq!(echo.invoke_tool_name, "alpha_invoke_tool");
    assert!(echo
        .description
        .as_deref()
        .unwrap_or_default()
        .contains("alpha"));
}

#[tokio::test]
async fn toonify_uses_official_toon_encoder_for_json_outputs() {
    let config = CompressedServerConfig {
        toonify: true,
        ..common::config(
            CompressionLevel::Low,
            Some("alpha"),
            ProxyTransformMode::CompressedTools,
            BackendConfigSource::Command,
        )
    };
    let server =
        CompressedServer::connect_stdio(config, common::backend("alpha", "alpha_server.py"))
            .await
            .unwrap();

    let output = server
        .invoke_tool("alpha_invoke_tool", "structured_data", json!({}))
        .await
        .unwrap();
    assert!(output.contains("server: alpha"));
    assert!(output.contains("values"));
}