stdio_client/
stdio_client.rs

1use mcprotocol_rs::{
2    protocol::{Message, Method, Request, RequestId},
3    transport::{ClientTransportFactory, TransportConfig, TransportType},
4    Result,
5};
6use serde_json::json;
7use std::{collections::HashSet, env, time::Duration};
8use tokio::time::sleep;
9
10#[tokio::main]
11async fn main() -> Result<()> {
12    // 跟踪会话中使用的请求 ID
13    // Track request IDs used in the session
14    let mut session_ids = HashSet::new();
15
16    // 获取服务器程序路径
17    // Get server program path
18    let server_path = env::current_dir()?.join("target/debug/examples/stdio_server");
19
20    // 配置 Stdio 客户端
21    // Configure Stdio client
22    let config = TransportConfig {
23        transport_type: TransportType::Stdio {
24            server_path: Some(server_path.to_str().unwrap().to_string()),
25            server_args: None,
26        },
27        parameters: None,
28    };
29
30    // 创建客户端实例
31    // Create client instance
32    let factory = ClientTransportFactory;
33    let mut client = factory.create(config)?;
34
35    // 初始化客户端
36    // Initialize client
37    client.initialize().await?;
38    eprintln!("Client initialized and connected to server...");
39
40    // 等待服务器初始化完成
41    // Wait for server initialization to complete
42    sleep(Duration::from_millis(100)).await;
43
44    // 创建请求
45    // Create request
46    let request_id = RequestId::Number(1);
47    let request = Request::new(
48        Method::ExecutePrompt,
49        Some(json!({
50            "content": "Hello from client!",
51            "role": "user"
52        })),
53        request_id,
54    );
55
56    // 验证请求 ID 的唯一性
57    // Validate request ID uniqueness
58    if !request.validate_id_uniqueness(&mut session_ids) {
59        eprintln!("Request ID has already been used in this session");
60        return Ok(());
61    }
62
63    // 发送消息
64    // Send message
65    eprintln!("Sending message to server...");
66    client.send(Message::Request(request)).await?;
67
68    // 接收服务器响应
69    // Receive server response
70    match client.receive().await {
71        Ok(response) => {
72            eprintln!("Received response: {:?}", response);
73            match response {
74                Message::Response(resp) => {
75                    if let Some(result) = resp.result {
76                        eprintln!("Server response result: {}", result);
77                    }
78                    if let Some(error) = resp.error {
79                        eprintln!(
80                            "Server response error: {} (code: {})",
81                            error.message, error.code
82                        );
83                    }
84                }
85                _ => eprintln!("Unexpected response type"),
86            }
87        }
88        Err(e) => {
89            eprintln!("Error receiving response: {}", e);
90        }
91    }
92
93    // 关闭客户端
94    // Close client
95    client.close().await?;
96    Ok(())
97}