reasonkit-core 0.1.8

The Reasoning Engine — Auditable Reasoning for Production AI | Rust-Native | Turn Prompts into Protocols
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! IPC Client Implementation
//!
//! Client for connecting to the MCP daemon via IPC.

use crate::error::{Error, Result};
use crate::mcp::tools::ToolResult;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use uuid::Uuid;

#[cfg(unix)]
use tokio::net::UnixStream;

use super::ipc_server::{IpcMessage, ToolInfo};

/// IPC client for daemon communication
pub struct IpcClient {
    #[cfg(unix)]
    stream: UnixStream,
}

impl IpcClient {
    /// Connect to daemon via IPC
    #[cfg(unix)]
    pub async fn connect() -> Result<Self> {
        let socket_path = super::manager::DaemonManager::get_socket_path()?;

        let stream = UnixStream::connect(&socket_path)
            .await
            .map_err(|e| Error::network(format!("Failed to connect to daemon: {}", e)))?;

        Ok(Self { stream })
    }

    /// Call a tool via daemon
    pub async fn call_tool(&mut self, name: &str, args: serde_json::Value) -> Result<ToolResult> {
        let msg = IpcMessage::CallTool {
            id: Uuid::new_v4().to_string(),
            tool: name.to_string(),
            args,
        };

        self.send_message(&msg).await?;
        let response = self.receive_message().await?;

        match response {
            IpcMessage::ToolResult { result, .. } => Ok(result),
            IpcMessage::Error { error, .. } => Err(Error::network(error)),
            _ => Err(Error::network("Unexpected response type")),
        }
    }

    /// List available tools
    pub async fn list_tools(&mut self) -> Result<Vec<ToolInfo>> {
        let msg = IpcMessage::ListTools {
            id: Uuid::new_v4().to_string(),
        };

        self.send_message(&msg).await?;
        let response = self.receive_message().await?;

        match response {
            IpcMessage::ToolsList { tools, .. } => Ok(tools),
            IpcMessage::Error { error, .. } => Err(Error::network(error)),
            _ => Err(Error::network("Unexpected response type")),
        }
    }

    /// Get daemon statistics
    pub async fn get_stats(&mut self) -> Result<(usize, u64, u64, u64)> {
        let msg = IpcMessage::GetStats {
            id: Uuid::new_v4().to_string(),
        };

        self.send_message(&msg).await?;
        let response = self.receive_message().await?;

        match response {
            IpcMessage::Stats {
                active_connections,
                total_calls,
                cache_hits,
                cache_misses,
                ..
            } => Ok((active_connections, total_calls, cache_hits, cache_misses)),
            IpcMessage::Error { error, .. } => Err(Error::network(error)),
            _ => Err(Error::network("Unexpected response type")),
        }
    }

    /// Ping daemon
    pub async fn ping(&mut self) -> Result<bool> {
        let msg = IpcMessage::Ping {
            id: Uuid::new_v4().to_string(),
        };

        self.send_message(&msg).await?;

        match tokio::time::timeout(std::time::Duration::from_secs(5), self.receive_message()).await
        {
            Ok(Ok(IpcMessage::Pong { .. })) => Ok(true),
            _ => Ok(false),
        }
    }

    /// Send shutdown signal to daemon
    pub async fn shutdown(&mut self) -> Result<()> {
        let msg = IpcMessage::Shutdown {
            id: Uuid::new_v4().to_string(),
        };

        self.send_message(&msg).await?;
        let response = self.receive_message().await?;

        match response {
            IpcMessage::Ok { .. } => Ok(()),
            IpcMessage::Error { error, .. } => Err(Error::network(error)),
            _ => Err(Error::network("Unexpected response type")),
        }
    }

    /// Send IPC message
    #[cfg(unix)]
    async fn send_message(&mut self, msg: &IpcMessage) -> Result<()> {
        let json = serde_json::to_vec(msg)?;
        let len = (json.len() as u32).to_le_bytes();

        self.stream.write_all(&len).await?;
        self.stream.write_all(&json).await?;
        self.stream.flush().await?;

        Ok(())
    }

    /// Receive IPC message
    #[cfg(unix)]
    async fn receive_message(&mut self) -> Result<IpcMessage> {
        let mut len_buf = [0u8; 4];
        self.stream.read_exact(&mut len_buf).await?;

        let len = u32::from_le_bytes(len_buf) as usize;
        let mut buf = vec![0u8; len];
        self.stream.read_exact(&mut buf).await?;

        Ok(serde_json::from_slice(&buf)?)
    }
}

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

    #[tokio::test]
    async fn test_ipc_client_connect_fails_when_no_daemon() {
        // Should fail when daemon not running
        let result = IpcClient::connect().await;
        assert!(result.is_err());
    }
}