spec-ai 0.6.12

A framework for building AI agents with structured outputs, policy enforcement, and execution tracking
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
126
127
128

use crate::spec_ai_core::tools::{Tool, ToolResult};
use anyhow::{Context, Result};
use async_trait::async_trait;
use serde::Deserialize;
use serde_json::Value;

/// A simple echo tool that returns its input
pub struct EchoTool;

#[derive(Debug, Deserialize)]
struct EchoArgs {
    message: String,
}

impl EchoTool {
    pub fn new() -> Self {
        Self
    }
}

impl Default for EchoTool {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait]
impl Tool for EchoTool {
    fn name(&self) -> &str {
        "echo"
    }

    fn description(&self) -> &str {
        "Echoes back the provided message"
    }

    fn parameters(&self) -> Value {
        serde_json::json!({
            "type": "object",
            "properties": {
                "message": {
                    "type": "string",
                    "description": "The message to echo back"
                }
            },
            "required": ["message"]
        })
    }

    async fn execute(&self, args: Value) -> Result<ToolResult> {
        let echo_args: EchoArgs =
            serde_json::from_value(args).context("Failed to parse echo arguments")?;

        Ok(ToolResult::success(echo_args.message))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_echo_tool_basic() {
        let tool = EchoTool::new();

        assert_eq!(tool.name(), "echo");
        assert!(!tool.description().is_empty());
    }

    #[tokio::test]
    async fn test_echo_tool_parameters() {
        let tool = EchoTool::new();
        let params = tool.parameters();

        assert!(params.is_object());
        assert!(params["properties"]["message"].is_object());
        assert_eq!(params["required"][0], "message");
    }

    #[tokio::test]
    async fn test_echo_tool_execute() {
        let tool = EchoTool::new();
        let args = serde_json::json!({
            "message": "Hello, world!"
        });

        let result = tool.execute(args).await.unwrap();

        assert!(result.success);
        assert_eq!(result.output, "Hello, world!");
        assert!(result.error.is_none());
    }

    #[tokio::test]
    async fn test_echo_tool_execute_empty_message() {
        let tool = EchoTool::new();
        let args = serde_json::json!({
            "message": ""
        });

        let result = tool.execute(args).await.unwrap();

        assert!(result.success);
        assert_eq!(result.output, "");
    }

    #[tokio::test]
    async fn test_echo_tool_execute_missing_argument() {
        let tool = EchoTool::new();
        let args = serde_json::json!({});

        let result = tool.execute(args).await;

        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_echo_tool_execute_invalid_type() {
        let tool = EchoTool::new();
        let args = serde_json::json!({
            "message": 123
        });

        let result = tool.execute(args).await;

        assert!(result.is_err());
    }
}