rig-mcp 0.2.1

Model Context Protocol bridge for rig-compose tool registries. Wraps the official `rmcp` SDK with rig-compose's transport-agnostic Tool surface.
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

use std::sync::Arc;

use rig_compose::{KernelError, LocalTool, ToolRegistry, ToolSchema};
use rig_mcp::serve_stdio;
use serde_json::{Value, json};

#[tokio::main]
async fn main() {
    if let Err(err) = serve_stdio(fixture_registry()).await {
        eprintln!("{err}");
        std::process::exit(1);
    }
}

fn fixture_registry() -> ToolRegistry {
    let registry = ToolRegistry::new();
    registry.register(Arc::new(LocalTool::new(
        ToolSchema {
            name: "weather.lookup".into(),
            description: "looks up weather for a city".into(),
            args_schema: json!({
                "type": "object",
                "required": ["city"],
                "properties": {
                    "city": {"type": "string"}
                }
            }),
            result_schema: json!({
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "forecast": {"type": "string"},
                    "transport": {"type": "string"}
                }
            }),
        },
        |args| async move {
            let city = args.get("city").and_then(Value::as_str).ok_or_else(|| {
                KernelError::InvalidArgument("weather.lookup requires city".into())
            })?;
            Ok(json!({
                "city": city,
                "forecast": "clear and cool",
                "transport": "stdio-mcp"
            }))
        },
    )));
    registry.register(Arc::new(LocalTool::new(
        ToolSchema {
            name: "math.checked_add".into(),
            description: "add two integers with argument validation".into(),
            args_schema: json!({
                "type": "object",
                "required": ["a", "b"],
                "properties": {
                    "a": {"type": "integer"},
                    "b": {"type": "integer"}
                }
            }),
            result_schema: json!({
                "type": "object",
                "properties": {
                    "sum": {"type": "integer"}
                }
            }),
        },
        |args| async move {
            let a = required_i64(&args, "a")?;
            let b = required_i64(&args, "b")?;
            let sum = a.checked_add(b).ok_or_else(|| {
                KernelError::InvalidArgument("math.checked_add overflowed".into())
            })?;
            Ok(json!({ "sum": sum }))
        },
    )));
    // Mid-RPC server exit. Used by tests/stdio_failures.rs to confirm
    // the client surfaces a typed `KernelError` (not a panic) when the
    // server vanishes after accepting the call but before responding.
    registry.register(Arc::new(LocalTool::new(
        ToolSchema {
            name: "diagnostics.exit_mid_rpc".into(),
            description: "terminate the server process before responding".into(),
            args_schema: json!({"type": "object"}),
            result_schema: json!({"type": "object"}),
        },
        |_args| async move {
            // Flush stderr so the test can attribute the exit if needed,
            // then drop the connection by terminating the process.
            std::process::exit(0);
            #[allow(unreachable_code)]
            Ok(json!({}))
        },
    )));
    // Oversized payload. Used by tests/result_envelope.rs to confirm
    // `rig_compose::bound_tool_result` is the supported truncation
    // surface for MCP responses (no per-transport bespoke clamping).
    registry.register(Arc::new(LocalTool::new(
        ToolSchema {
            name: "diagnostics.big_payload".into(),
            description: "return a deterministically oversized payload".into(),
            args_schema: json!({"type": "object"}),
            result_schema: json!({
                "type": "object",
                "properties": {
                    "blob": {"type": "string"},
                    "items": {"type": "array"}
                }
            }),
        },
        |_args| async move {
            let blob: String = std::iter::repeat_n('x', 10_000).collect();
            let items: Vec<Value> = (0..200i64).map(|i| json!(i)).collect();
            Ok(json!({ "blob": blob, "items": items }))
        },
    )));
    registry
}

fn required_i64(args: &Value, name: &str) -> Result<i64, KernelError> {
    args.get(name).and_then(Value::as_i64).ok_or_else(|| {
        KernelError::InvalidArgument(format!("math.checked_add requires integer {name}"))
    })
}