kyma-mcp 0.0.1

JSON-RPC 2.0 Model Context Protocol server over Streamable HTTP.
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

//! Transport-agnostic JSON-RPC method dispatch for the MCP server.
//!
//! Both transports — the HTTP Streamable router (`router.rs`) and the stdio
//! loop (`stdio.rs`) — call [`dispatch_request`], so they speak exactly the
//! same protocol. The only difference is framing (HTTP body vs newline-
//! delimited stdin/stdout).

use serde_json::{json, Value};
use tracing::debug;

use crate::initialize::{handle_initialize, ServerInfo};
use crate::jsonrpc::{ErrorCode, ErrorObject, Request, Response};
use crate::tools::ToolDispatch;

/// Dispatch a single JSON-RPC request against the tool dispatch + server info.
///
/// Returns `None` for notifications (id-less requests, e.g.
/// `notifications/initialized`) — the caller emits no response for those.
pub async fn dispatch_request(
    dispatch: &ToolDispatch,
    server_info: &ServerInfo,
    req: Request,
) -> Option<Response> {
    let id = req.id.clone();
    let result: Result<Value, ErrorObject> = match req.method.as_str() {
        "initialize" => handle_initialize(req.params.unwrap_or(json!({})), server_info),
        "notifications/initialized" => return None,
        "tools/list" => Ok(json!({ "tools": dispatch.list() })),
        "tools/call" => match req.params {
            Some(p) => {
                let name = p.get("name").and_then(|v| v.as_str()).map(str::to_owned);
                let arguments = p.get("arguments").cloned().unwrap_or(json!({}));
                match name {
                    Some(n) => {
                        ::metrics::counter!("kyma_mcp_tool_calls_total", "tool" => n.clone())
                            .increment(1);
                        let outcome = dispatch.call(&n, arguments).await;
                        let result_label = if outcome.is_ok() { "ok" } else { "error" };
                        ::metrics::counter!(
                            "kyma_mcp_tool_results_total",
                            "tool" => n.clone(),
                            "result" => result_label
                        )
                        .increment(1);
                        outcome
                    }
                    None => Err(ErrorObject::new(
                        ErrorCode::InvalidParams as i64,
                        "tools/call requires `name`",
                    )),
                }
            }
            None => Err(ErrorObject::new(
                ErrorCode::InvalidParams as i64,
                "tools/call requires params",
            )),
        },
        other => {
            debug!(method = %other, "mcp: method not found");
            Err(ErrorObject::new(
                ErrorCode::MethodNotFound as i64,
                format!("method not found: {other}"),
            ))
        }
    };
    match id {
        Some(id) => Some(match result {
            Ok(value) => Response::success(id, value),
            Err(err) => Response::error(id, err),
        }),
        None => None, // id-less request is a notification per JSON-RPC 2.0.
    }
}