radkit-macros 0.0.2

Procedural macros for the radkit agent framework
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
129
130
131
132
133
134
135
136
137
138
139
140

use radkit::agent::{OnRequestResult, RegisteredSkill, SkillHandler};
use radkit::errors::AgentError;
use radkit::models::Content;
use radkit::runtime::context::{Context, TaskContext};
use radkit::runtime::Runtime;
use radkit_macros::skill;

// Test 1: Basic skill with required fields only
#[skill(id = "test_skill", name = "Test Skill", description = "A test skill")]
struct TestSkill;

#[cfg_attr(
    all(target_os = "wasi", target_env = "p1"),
    async_trait::async_trait(?Send)
)]
#[cfg_attr(
    not(all(target_os = "wasi", target_env = "p1")),
    async_trait::async_trait
)]
impl SkillHandler for TestSkill {
    async fn on_request(
        &self,
        _task_context: &mut TaskContext,
        _context: &Context,
        _runtime: &dyn Runtime,
        _content: Content,
    ) -> Result<OnRequestResult, AgentError> {
        Ok(OnRequestResult::Completed {
            message: Some(Content::from_text("Test response")),
            artifacts: vec![],
        })
    }
}

// Test 2: Skill with all fields
#[skill(
    id = "full_skill",
    name = "Full Test Skill",
    description = "A skill with all parameters",
    tags = ["test", "example"],
    examples = ["Example 1", "Example 2"],
    input_modes = ["text/plain", "application/json"],
    output_modes = ["text/plain"]
)]
struct FullSkill;

#[cfg_attr(
    all(target_os = "wasi", target_env = "p1"),
    async_trait::async_trait(?Send)
)]
#[cfg_attr(
    not(all(target_os = "wasi", target_env = "p1")),
    async_trait::async_trait
)]
impl SkillHandler for FullSkill {
    async fn on_request(
        &self,
        _task_context: &mut TaskContext,
        _context: &Context,
        _runtime: &dyn Runtime,
        _content: Content,
    ) -> Result<OnRequestResult, AgentError> {
        Ok(OnRequestResult::Completed {
            message: Some(Content::from_text("Full skill response")),
            artifacts: vec![],
        })
    }
}

// Test 3: Skill with empty arrays
#[skill(
    id = "empty_arrays_skill",
    name = "Empty Arrays Skill",
    description = "A skill with explicit empty arrays",
    tags = [],
    examples = [],
    input_modes = [],
    output_modes = []
)]
struct EmptyArraysSkill;

#[cfg_attr(
    all(target_os = "wasi", target_env = "p1"),
    async_trait::async_trait(?Send)
)]
#[cfg_attr(
    not(all(target_os = "wasi", target_env = "p1")),
    async_trait::async_trait
)]
impl SkillHandler for EmptyArraysSkill {
    async fn on_request(
        &self,
        _task_context: &mut TaskContext,
        _context: &Context,
        _runtime: &dyn Runtime,
        _content: Content,
    ) -> Result<OnRequestResult, AgentError> {
        Ok(OnRequestResult::Completed {
            message: Some(Content::from_text("Empty arrays skill response")),
            artifacts: vec![],
        })
    }
}

#[test]
fn test_basic_skill_metadata() {
    // Verify that metadata() is callable
    let metadata = TestSkill::metadata();
    assert_eq!(metadata.id, "test_skill");
    assert_eq!(metadata.name, "Test Skill");
    assert_eq!(metadata.description, "A test skill");
    assert_eq!(metadata.tags.len(), 0);
    assert_eq!(metadata.examples.len(), 0);
    assert_eq!(metadata.input_modes.len(), 0);
    assert_eq!(metadata.output_modes.len(), 0);
}

#[test]
fn test_full_skill_metadata() {
    let metadata = FullSkill::metadata();
    assert_eq!(metadata.id, "full_skill");
    assert_eq!(metadata.name, "Full Test Skill");
    assert_eq!(metadata.description, "A skill with all parameters");
    assert_eq!(metadata.tags, &["test", "example"]);
    assert_eq!(metadata.examples, &["Example 1", "Example 2"]);
    assert_eq!(metadata.input_modes, &["text/plain", "application/json"]);
    assert_eq!(metadata.output_modes, &["text/plain"]);
}

#[test]
fn test_empty_arrays_skill_metadata() {
    let metadata = EmptyArraysSkill::metadata();
    assert_eq!(metadata.id, "empty_arrays_skill");
    assert_eq!(metadata.name, "Empty Arrays Skill");
    assert_eq!(metadata.description, "A skill with explicit empty arrays");
    assert_eq!(metadata.tags.len(), 0);
    assert_eq!(metadata.examples.len(), 0);
    assert_eq!(metadata.input_modes.len(), 0);
    assert_eq!(metadata.output_modes.len(), 0);
}