neva 0.3.2

MCP SDK for Rust
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

//! Fluent task-augmented request builder for the MCP client

use super::Client;
use crate::{
    error::{Error, ErrorCode},
    shared::{self, IntoArgs},
    types::{CallToolRequestParams, CallToolResponse, TaskMetadata},
};

/// A fluent builder for constructing and sending a task-augmented `tools/call` request.
///
/// Obtain via [`Client::task`]. Configure task options with the provided setters,
/// then call [`TaskBuilder::call_tool`] to execute.
///
/// # Example
/// ```no_run
/// use neva::client::Client;
/// use neva::error::Error;
///
/// #[tokio::main]
/// async fn main() -> Result<(), Error> {
///     let mut client = Client::new();
///     client.connect().await?;
///
///     let result = client
///         .task()
///         .with_ttl(5000)
///         .call_tool("echo", [("message", "Hello MCP!")])
///         .await?;
///
///     println!("{result:?}");
///     client.disconnect().await
/// }
/// ```
pub struct TaskBuilder<'a> {
    pub(super) client: &'a mut Client,
    pub(super) metadata: TaskMetadata,
}

impl std::fmt::Debug for TaskBuilder<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TaskBuilder")
            .field("metadata", &self.metadata)
            .finish_non_exhaustive()
    }
}

impl<'a> TaskBuilder<'a> {
    /// Sets the time-to-live (in milliseconds) for the task.
    ///
    /// This requests the server to retain the task for at most `ttl` milliseconds
    /// after creation.
    pub fn with_ttl(mut self, ttl: usize) -> Self {
        self.metadata.ttl = Some(ttl);
        self
    }

    /// Sends a task-augmented `tools/call` request and waits for the task to complete.
    ///
    /// # Errors
    /// Returns [`Error`] if the server does not support task-augmented tool calls,
    /// or if the underlying request fails.
    pub async fn call_tool<N, Args>(self, name: N, args: Args) -> Result<CallToolResponse, Error>
    where
        N: Into<String>,
        Args: IntoArgs,
    {
        if !self.client.is_server_support_call_tool_with_tasks() {
            return Err(Error::new(
                ErrorCode::InvalidRequest,
                "Server does not support call tool with tasks.",
            ));
        }

        let params = CallToolRequestParams {
            name: name.into(),
            meta: None,
            args: args.into_args(),
            task: Some(self.metadata),
        };

        let result = self.client.call_tool_raw(params).await?.into_result()?;
        shared::wait_to_completion(self.client, result).await
    }
}