anttp 0.26.0

AntTP is an HTTP server for the Autonomi Network
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

#![allow(dead_code)]

use rmcp::{handler::server::{
    wrapper::Parameters,
}, schemars, tool, tool_router, ErrorData};
use rmcp::model::{CallToolResult, ErrorCode};
use rmcp::schemars::JsonSchema;
use serde::Deserialize;
use serde_json::json;
use crate::model::resolve::Resolve;
use crate::tool::McpTool;

#[derive(Debug, Deserialize, JsonSchema)]
struct ResolveRequest {
    #[schemars(description = "Source name or address to resolve")]
    name: String,
}

impl From<Resolve> for CallToolResult {
    fn from(resolve: Resolve) -> CallToolResult {
        CallToolResult::structured(json!(resolve))
    }
}

#[tool_router(router = resolver_tool_router, vis = "pub")]
impl McpTool {

    #[tool(description = "Resolve a source name or address to its target address")]
    async fn resolve(
        &self,
        Parameters(ResolveRequest { name }): Parameters<ResolveRequest>,
    ) -> Result<CallToolResult, ErrorData> {
        match self.resolver_service.resolve_name_item(&name).await {
            Some(resolve) => Ok(resolve.into()),
            None => Err(ErrorData::new(ErrorCode::INVALID_PARAMS, format!("Address for [{}] not found", name), None)),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_resolve_request_serialization() {
        let json = r#"{
            "name": "test_name"
        }"#;
        let request: ResolveRequest = serde_json::from_str(json).unwrap();
        assert_eq!(request.name, "test_name");
    }
}