wauldo 0.10.0

Official Rust SDK for Wauldo — Verified AI answers from your documents
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
125

//! Wauldo client — struct definition, constructor, tool primitives

mod chunking;
mod concepts;
mod knowledge;
mod parsers;
mod planning;
mod reasoning;

use serde_json::json;

use crate::error::{Error, Result};
use crate::transport::StdioTransport;
use crate::types::*;

/// Client for Wauldo MCP Server
///
/// # Example
///
/// ```rust,no_run
/// use wauldo::{AgentClient, ReasoningOptions};
///
/// #[tokio::main]
/// async fn main() -> wauldo::Result<()> {
///     let mut client = AgentClient::new().connect().await?;
///
///     let result = client.reason("How to optimize?").await?;
///     println!("{}", result.solution);
///
///     client.disconnect().await;
///     Ok(())
/// }
/// ```
pub struct AgentClient {
    pub(crate) transport: StdioTransport,
    pub(crate) auto_connect: bool,
    pub(crate) connected: bool,
}

impl AgentClient {
    /// Create a new client with default options
    pub fn new() -> Self {
        Self::with_options(ClientOptions::default())
    }

    /// Create a new client with custom options
    pub fn with_options(options: ClientOptions) -> Self {
        Self {
            transport: StdioTransport::new(options.server_path, options.timeout_ms),
            auto_connect: options.auto_connect,
            connected: false,
        }
    }

    /// Connect to MCP server
    pub async fn connect(mut self) -> Result<Self> {
        self.transport.connect().await?;
        self.connected = true;
        Ok(self)
    }

    /// Disconnect from MCP server
    pub async fn disconnect(&mut self) {
        self.transport.disconnect().await;
        self.connected = false;
    }

    /// Ensure client is connected
    pub(crate) async fn ensure_connected(&mut self) -> Result<()> {
        if !self.connected {
            if self.auto_connect {
                self.transport.connect().await?;
                self.connected = true;
            } else {
                return Err(Error::connection("Not connected. Call connect() first."));
            }
        }
        Ok(())
    }

    /// List available tools
    pub async fn list_tools(&mut self) -> Result<Vec<ToolDefinition>> {
        self.ensure_connected().await?;
        let result = self.transport.request("tools/list", None).await?;
        let tools = result
            .get("tools")
            .and_then(|t| serde_json::from_value(t.clone()).ok())
            .unwrap_or_default();
        Ok(tools)
    }

    /// Call a tool by name
    pub async fn call_tool(&mut self, name: &str, arguments: serde_json::Value) -> Result<String> {
        self.ensure_connected().await?;
        let result = self
            .transport
            .request(
                "tools/call",
                Some(json!({
                    "name": name,
                    "arguments": arguments
                })),
            )
            .await?;

        let content = result
            .get("content")
            .and_then(|c| c.as_array())
            .and_then(|arr| arr.first())
            .and_then(|item| item.get("text"))
            .and_then(|t| t.as_str())
            .unwrap_or("")
            .to_string();

        Ok(content)
    }
}

/// Creates a disconnected client with default options.
/// Call `.connect().await?` before using MCP methods.
impl Default for AgentClient {
    fn default() -> Self {
        Self::new()
    }
}