nemo-relay-cli 0.6.0-rc.1

Coding-agent gateway CLI for NeMo Relay observability.
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

// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

//! Minimal MCP/JSON-RPC protocol implemented by the lifecycle client.

use serde_json::{Value, json};

pub(super) const MCP_PROTOCOL_VERSION: &str = "2025-11-25";
pub(super) const MCP_SUPPORTED_PROTOCOL_VERSIONS: &[&str] = &[MCP_PROTOCOL_VERSION, "2025-06-18"];

/// Result of decoding one newline-delimited MCP frame.
pub(super) struct FrameAction {
    pub(super) response: Option<Value>,
}

/// Parse a frame once and derive its protocol response.
pub(super) fn evaluate_frame(frame: &str) -> FrameAction {
    match serde_json::from_str::<Value>(frame) {
        Ok(message) => FrameAction {
            response: response_for(&message),
        },
        Err(_) => FrameAction {
            response: Some(jsonrpc_error(Value::Null, -32700, "Parse error")),
        },
    }
}

pub(super) fn response_for(message: &Value) -> Option<Value> {
    let raw_id = message.get("id");
    let response_id = raw_id
        .filter(|id| valid_request_id(id))
        .cloned()
        .unwrap_or(Value::Null);
    if !message.is_object() || message.get("jsonrpc").and_then(Value::as_str) != Some("2.0") {
        return Some(jsonrpc_error(response_id, -32600, "Invalid Request"));
    }
    let method = message.get("method").and_then(Value::as_str);
    if raw_id.is_some_and(|id| !valid_request_id(id)) {
        return Some(jsonrpc_error(Value::Null, -32600, "Invalid Request"));
    }
    if method.is_none() {
        return Some(jsonrpc_error(response_id, -32600, "Invalid Request"));
    }
    let id = raw_id?.clone();
    match method {
        Some("initialize") => {
            let Some(requested_protocol) = message
                .pointer("/params/protocolVersion")
                .and_then(Value::as_str)
            else {
                return Some(jsonrpc_error(id, -32602, "Missing protocolVersion"));
            };
            let protocol_version = if MCP_SUPPORTED_PROTOCOL_VERSIONS.contains(&requested_protocol)
            {
                requested_protocol
            } else {
                MCP_PROTOCOL_VERSION
            };
            Some(json!({
                "jsonrpc": "2.0",
                "id": id,
                "result": {
                    "protocolVersion": protocol_version,
                    "capabilities": {},
                    "serverInfo": {
                        "name": "nemo-relay",
                        "version": env!("CARGO_PKG_VERSION")
                    }
                }
            }))
        }
        Some("tools/list") => Some(json!({
            "jsonrpc": "2.0",
            "id": id,
            "result": { "tools": [] }
        })),
        Some("ping") => Some(json!({
            "jsonrpc": "2.0",
            "id": id,
            "result": {}
        })),
        Some(_) => Some(jsonrpc_error(id, -32601, "Method not found")),
        None => Some(jsonrpc_error(id, -32600, "Invalid Request")),
    }
}

fn valid_request_id(id: &Value) -> bool {
    id.is_string() || id.as_i64().is_some() || id.as_u64().is_some()
}

pub(super) fn jsonrpc_error(id: Value, code: i64, message: &str) -> Value {
    json!({
        "jsonrpc": "2.0",
        "id": id,
        "error": {
            "code": code,
            "message": message
        }
    })
}