ftl-core 0.0.2

Core library for FTL tools - lightweight MCP server for WebAssembly
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

use serde_json::Value;

use crate::types::{ToolError, ToolResult};

/// Trait that all FTL Core tools must implement
///
/// This trait defines a single computational tool optimized for WebAssembly
/// performance. FTL Core follows the "1 tool per server" architecture for
/// maximum efficiency.
pub trait Tool: Clone {
    /// The name of the tool (used in MCP tool calls)
    fn name(&self) -> &'static str;

    /// Human-readable description of what the tool does
    fn description(&self) -> &'static str;

    /// JSON schema for the tool's input parameters
    ///
    /// Return a JSON object describing the expected input structure.
    /// Example:
    /// ```json
    /// {
    ///   "type": "object",
    ///   "properties": {
    ///     "text": {
    ///       "type": "string",
    ///       "description": "The text to process"
    ///     }
    ///   },
    ///   "required": ["text"]
    /// }
    /// ```
    fn input_schema(&self) -> Value;

    /// Execute the tool with the provided arguments
    ///
    /// This is where your tool's core logic goes. The arguments are validated
    /// against your input schema before this method is called.
    fn call(&self, arguments: &Value) -> Result<ToolResult, ToolError>;

    /// Optional: Custom server name (defaults to tool name)
    fn server_name(&self) -> String {
        format!("ftl-{}", self.name())
    }

    /// Optional: Server version (defaults to "0.0.1")
    fn server_version(&self) -> &'static str {
        "0.0.1"
    }

    /// Optional: Additional server capabilities
    fn capabilities(&self) -> Value {
        serde_json::json!({
            "tools": {}
        })
    }
}

/// Information about a tool for MCP tool listing
#[derive(Debug)]
pub struct ToolInfo {
    pub name: String,
    pub description: String,
    pub input_schema: Value,
}

impl<T: Tool> From<&T> for ToolInfo {
    fn from(tool: &T) -> Self {
        Self {
            name: tool.name().to_string(),
            description: tool.description().to_string(),
            input_schema: tool.input_schema(),
        }
    }
}