omcp 0.2.0

Utility functions
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
124

use std::collections::HashMap;

use log::{error, info};
use tokio::{
    io::{self, AsyncReadExt, AsyncWriteExt, BufReader, BufWriter, Stdin},
    select,
};

use crate::{
    error::{Error, Result},
    json_rpc::JsonRPCMessage,
    types::BakedMcpToolTrait,
};

const IO_BUFFER_SIZE: usize = 8 * 1024;

pub struct OmcpServer<E> {
    tools: HashMap<String, Box<dyn BakedMcpToolTrait<Error = E>>>,
}

////////////////////////////////////////////////////////////////////////////////
// PRIVATE FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
async fn read_all(stream: &mut BufReader<Stdin>) -> Result<String> {
    let mut vec: Vec<u8> = Vec::new();

    let mut buffer = vec![0u8; IO_BUFFER_SIZE];

    loop {
        match stream.read(&mut buffer).await {
            Ok(len) => {
                info!("len: {len}");

                if 0 == len {
                    return Err(Error::Eof);
                }

                vec.extend(&buffer[0..len]);

                if vec.ends_with(b"\r\n\r\n") {
                    break;
                }
            }
            Err(e) => {
                error!("{e}");
                return Err(e.into());
            }
        }
    }

    Ok(String::from_utf8(vec)?)
}

async fn process_message(_msg: &JsonRPCMessage) -> Result<JsonRPCMessage> {
    unimplemented!()
}

////////////////////////////////////////////////////////////////////////////////
// IMPL
////////////////////////////////////////////////////////////////////////////////
impl<E> OmcpServer<E> {
    pub fn new() -> Self {
        Self { tools: HashMap::new() }
    }

    pub fn add_tool<S, T>(&mut self, name: S, client: T)
    where
        S: AsRef<str>,
        T: BakedMcpToolTrait<Error = E> + 'static,
    {
        let boxed_client = Box::new(client);
        self.tools.insert(name.as_ref().to_string(), boxed_client);
    }

    pub fn start(&mut self) -> Result<()> {
        Ok(())
    }

    pub async fn io_loop(&mut self) -> Result<()> {
        let mut stdin_reader = BufReader::new(io::stdin());
        let mut stdout_writer = BufWriter::new(io::stdout());

        loop {
            select! {
               local = read_all(&mut stdin_reader) => {
                   match local{
                       Ok(msg) => {

                           let req: JsonRPCMessage = match serde_json::from_str(&msg){
                               Ok(v) => v,
                               Err(e) => {
                                   error!("{e}");
                                   continue
                               }
                           };

                           let res = match process_message(&req).await{
                               Ok(v) => v,
                               Err(e) => {
                                   error!("{e}");
                                   continue
                               }
                           };

                           let res = match serde_json::to_string(&res){
                               Ok(v) => v,
                               Err(e) => {
                                   error!("{e}");
                                   continue
                               }
                           };

                           stdout_writer.write_all(res.as_bytes()).await?;
                       }
                       Err(e) => {
                           error!("{e}");
                           break Err(e.into())
                       }
                   }
               }
            }
        }
    }
}