chabeau 0.7.1

A full-screen terminal chat interface that connects to various AI APIs for real-time conversations
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

use super::{format_rpc_error, format_unexpected_server_message};
use crate::core::config::data::McpServerConfig;
use rust_mcp_schema::schema_utils::ServerMessage;
use rust_mcp_schema::{
    CallToolResult, GetPromptResult, InitializeResult, ListPromptsResult,
    ListResourceTemplatesResult, ListResourcesResult, ListToolsResult, ReadResourceResult,
    LATEST_PROTOCOL_VERSION,
};
use serde_json::Value;

pub(crate) fn requested_protocol_version(config: &McpServerConfig) -> String {
    config
        .protocol_version
        .clone()
        .unwrap_or_else(|| LATEST_PROTOCOL_VERSION.to_string())
}

pub(crate) fn effective_protocol_version(
    config: &McpServerConfig,
    negotiated_version: Option<&str>,
) -> String {
    match negotiated_version {
        Some(version) if !version.trim().is_empty() => version.to_string(),
        _ => requested_protocol_version(config),
    }
}

pub(crate) fn parse_initialize_result(message: ServerMessage) -> Result<InitializeResult, String> {
    let value = parse_response_value(message)?;
    let result =
        serde_json::from_value::<InitializeResult>(value).map_err(|err| err.to_string())?;
    if result.protocol_version.trim().is_empty() {
        return Err("Unexpected initialize response.".to_string());
    }
    Ok(result)
}

pub(crate) fn parse_list_tools(message: ServerMessage) -> Result<ListToolsResult, String> {
    parse_response(message)
}

pub(crate) fn parse_list_resources(message: ServerMessage) -> Result<ListResourcesResult, String> {
    parse_response(message)
}

pub(crate) fn parse_list_resource_templates(
    message: ServerMessage,
) -> Result<ListResourceTemplatesResult, String> {
    parse_response(message)
}

pub(crate) fn parse_list_prompts(message: ServerMessage) -> Result<ListPromptsResult, String> {
    parse_response(message)
}

pub(crate) fn parse_get_prompt(message: ServerMessage) -> Result<GetPromptResult, String> {
    parse_response(message)
}

pub(crate) fn parse_read_resource(message: ServerMessage) -> Result<ReadResourceResult, String> {
    parse_response(message)
}

pub(crate) fn parse_call_tool(message: ServerMessage) -> Result<CallToolResult, String> {
    parse_response(message)
}

fn parse_response<T: serde::de::DeserializeOwned>(message: ServerMessage) -> Result<T, String> {
    let value = parse_response_value(message)?;
    serde_json::from_value::<T>(value).map_err(|err| err.to_string())
}

pub(crate) fn parse_response_value(message: ServerMessage) -> Result<Value, String> {
    match message {
        ServerMessage::Response(response) => {
            serde_json::to_value(&response.result).map_err(|err| err.to_string())
        }
        ServerMessage::Error(error) => Err(format_rpc_error(&error.error)),
        other => Err(format_unexpected_server_message(&other)),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::config::data::McpServerConfig;

    #[test]
    fn parse_initialize_rejects_blank_protocol_version() {
        let message = serde_json::from_value(serde_json::json!({
            "jsonrpc": "2.0",
            "id": 1,
            "result": {
            "capabilities": {},
            "protocolVersion": " ",
            "serverInfo": {"name": "x", "version": "1.0.0"}
            }
        }))
        .expect("message should parse");

        assert!(parse_initialize_result(message).is_err());
    }

    #[test]
    fn effective_protocol_prefers_negotiated() {
        let config = McpServerConfig {
            id: "alpha".to_string(),
            display_name: "Alpha".to_string(),
            base_url: None,
            command: None,
            args: None,
            env: None,
            headers: None,
            transport: None,
            allowed_tools: None,
            protocol_version: Some("2025-01-01".to_string()),
            enabled: Some(true),
            tool_payloads: None,
            tool_payload_window: None,
            yolo: None,
        };

        assert_eq!(
            effective_protocol_version(&config, Some("2025-11-25")),
            "2025-11-25"
        );
        assert_eq!(effective_protocol_version(&config, None), "2025-01-01");
    }
}