claude-agent 0.2.25

Rust SDK for building AI agents with Anthropic's Claude - Direct API, no CLI dependency
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

//! MCP tool wrapper for seamless integration with ToolRegistry.

use std::sync::Arc;

use async_trait::async_trait;
use serde_json::Value;

use super::{ExecutionContext, Tool};
use crate::mcp::{McpManager, McpToolDefinition, make_mcp_name, parse_mcp_name};
use crate::types::{ToolDefinition, ToolResult};

/// Wrapper that adapts an MCP tool to the Tool trait.
///
/// This enables MCP tools to be registered in ToolRegistry and called
/// through the standard tool execution pipeline.
pub struct McpToolWrapper {
    manager: Arc<McpManager>,
    qualified_name: String,
    server_name: String,
    tool_name: String,
    definition: McpToolDefinition,
}

impl McpToolWrapper {
    pub fn new(
        manager: Arc<McpManager>,
        server_name: impl Into<String>,
        tool: McpToolDefinition,
    ) -> Self {
        let server_name = server_name.into();
        let qualified_name = make_mcp_name(&server_name, &tool.name);
        Self {
            manager,
            qualified_name,
            server_name,
            tool_name: tool.name.clone(),
            definition: tool,
        }
    }

    pub fn qualified_name(&self) -> &str {
        &self.qualified_name
    }

    pub fn server_name(&self) -> &str {
        &self.server_name
    }

    pub fn tool_name(&self) -> &str {
        &self.tool_name
    }
}

#[async_trait]
impl Tool for McpToolWrapper {
    fn name(&self) -> &str {
        &self.qualified_name
    }

    fn description(&self) -> &str {
        &self.definition.description
    }

    fn input_schema(&self) -> Value {
        self.definition.input_schema.clone()
    }

    fn definition(&self) -> ToolDefinition {
        ToolDefinition::new(
            &self.qualified_name,
            &self.definition.description,
            self.definition.input_schema.clone(),
        )
    }

    async fn execute(&self, input: Value, _context: &ExecutionContext) -> ToolResult {
        match self.manager.call_tool(&self.qualified_name, input).await {
            Ok(result) => {
                if result.is_error {
                    ToolResult::error(result.to_string_content())
                } else {
                    ToolResult::success(result.to_string_content())
                }
            }
            Err(e) => ToolResult::error(e.to_string()),
        }
    }
}

/// Creates MCP tool wrappers for all tools from an McpManager.
pub async fn create_mcp_tools(manager: Arc<McpManager>) -> Vec<Arc<dyn Tool>> {
    let tools_list = manager.list_tools().await;
    let mut wrappers: Vec<Arc<dyn Tool>> = Vec::with_capacity(tools_list.len());

    for (qualified_name, definition) in tools_list {
        if let Some((server, _tool)) = parse_mcp_name(&qualified_name) {
            let wrapper = McpToolWrapper::new(Arc::clone(&manager), server, definition);
            wrappers.push(Arc::new(wrapper));
        }
    }

    wrappers
}