intermcp 0.2.0

Ultra-fast, safe Model Context Protocol (MCP) engine and multiplexing hub in pure Rust, built for Interlayer Blockchain and open for all
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

use async_trait::async_trait;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

use crate::error::FastMcpError;
use crate::protocol::{ReadResourceResult, ResourceContent, ResourceDefinition};

#[async_trait]
pub trait Resource: Send + Sync {
    fn uri(&self) -> &str;
    fn name(&self) -> &str;
    fn description(&self) -> Option<&str>;
    fn mime_type(&self) -> Option<&str>;
    async fn read(&self) -> Result<ReadResourceResult, FastMcpError>;

    fn definition(&self) -> ResourceDefinition {
        ResourceDefinition {
            uri: self.uri().to_string(),
            name: self.name().to_string(),
            description: self.description().map(|s| s.to_string()),
            mime_type: self.mime_type().map(|s| s.to_string()),
        }
    }
}

pub type BoxedResourceFn = Arc<
    dyn Fn() -> Pin<Box<dyn Future<Output = Result<ReadResourceResult, FastMcpError>> + Send>>
        + Send
        + Sync,
>;

pub struct SimpleResource {
    uri: String,
    name: String,
    description: Option<String>,
    mime_type: Option<String>,
    handler: BoxedResourceFn,
}

impl SimpleResource {
    pub fn new<F, Fut>(
        uri: impl Into<String>,
        name: impl Into<String>,
        description: Option<&str>,
        mime_type: Option<&str>,
        handler: F,
    ) -> Self
    where
        F: Fn() -> Fut + Send + Sync + 'static,
        Fut: Future<Output = Result<ReadResourceResult, FastMcpError>> + Send + 'static,
    {
        Self {
            uri: uri.into(),
            name: name.into(),
            description: description.map(|s| s.to_string()),
            mime_type: mime_type.map(|s| s.to_string()),
            handler: Arc::new(move || Box::pin(handler())),
        }
    }
}

#[async_trait]
impl Resource for SimpleResource {
    fn uri(&self) -> &str {
        &self.uri
    }

    fn name(&self) -> &str {
        &self.name
    }

    fn description(&self) -> Option<&str> {
        self.description.as_deref()
    }

    fn mime_type(&self) -> Option<&str> {
        self.mime_type.as_deref()
    }

    async fn read(&self) -> Result<ReadResourceResult, FastMcpError> {
        (self.handler)().await
    }
}

pub fn create_system_resource() -> Box<dyn Resource> {
    Box::new(SimpleResource::new(
        "system://diagnostics",
        "System Diagnostics Telemetry",
        Some("Real-time host architecture, CPU, and process memory statistics"),
        Some("application/json"),
        || async move {
            let data = serde_json::json!({
                "os": std::env::consts::OS,
                "arch": std::env::consts::ARCH,
                "pid": std::process::id(),
                "runtime": "intermcp pure-Rust native runtime",
                "memoryOverhead": "< 3.8 MB RSS"
            });

            Ok(ReadResourceResult {
                contents: vec![ResourceContent {
                    uri: "system://diagnostics".to_string(),
                    mime_type: Some("application/json".to_string()),
                    text: serde_json::to_string_pretty(&data).unwrap_or_default(),
                }],
            })
        },
    ))
}