1use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Clone, Default, Serialize, Deserialize)]
15pub struct SkillStoreItem {
16 pub id: String,
17 #[serde(rename = "pluginId")]
18 pub plugin_id: String,
19 pub key: String,
20 pub name: String,
21 pub description: String,
22 pub icon: String,
23 pub category: String,
24 #[serde(rename = "inputSchema")]
25 pub input_schema: String,
26 #[serde(rename = "outputSchema")]
27 pub output_schema: String,
28 pub timeout: i64,
29 #[serde(rename = "retryCount")]
30 pub retry_count: i64,
31 #[serde(rename = "retryDelay")]
32 pub retry_delay: i64,
33 pub version: String,
34 #[serde(rename = "totalCalls")]
35 pub total_calls: i64,
36 #[serde(rename = "avgDurationMs")]
37 pub avg_duration_ms: i64,
38 #[serde(rename = "successRate")]
39 pub success_rate: f64,
40 #[serde(rename = "isEnabled")]
41 pub is_enabled: bool,
42 #[serde(rename = "securityLevel")]
43 pub security_level: String,
44 #[serde(rename = "securityScore")]
45 pub security_score: i64,
46 pub scope: String,
47 pub status: String,
48 #[serde(rename = "downloadCount")]
49 pub download_count: i64,
50 #[serde(default, skip_serializing_if = "Option::is_none")]
52 pub readme: Option<String>,
53 #[serde(rename = "skillMd", default, skip_serializing_if = "Option::is_none")]
55 pub skill_md: Option<String>,
56 pub tags: Vec<String>,
57 pub author: String,
58 #[serde(rename = "publisherId")]
59 pub publisher_id: String,
60 #[serde(rename = "isPublished")]
61 pub is_published: bool,
62 #[serde(rename = "pluginName")]
63 pub plugin_name: String,
64 #[serde(rename = "pluginIcon")]
65 pub plugin_icon: String,
66 #[serde(rename = "updatedAt")]
67 pub updated_at: String,
68 #[serde(default, skip_serializing_if = "Option::is_none")]
69 pub visibility: Option<String>,
70 #[serde(
71 rename = "certificationStatus",
72 default,
73 skip_serializing_if = "Option::is_none"
74 )]
75 pub certification_status: Option<String>,
76 #[serde(default, skip_serializing_if = "Option::is_none")]
77 pub source: Option<String>,
78}
79
80#[derive(Debug, Clone, Default)]
82pub struct SkillStoreQuery {
83 pub category: Option<String>,
84 pub keyword: Option<String>,
85 pub tag: Option<String>,
86}
87
88#[derive(Debug, Clone, Default, Serialize, Deserialize)]
90pub struct SkillSummary {
91 pub installed: i64,
92 pub created: i64,
93 pub total: i64,
94 #[serde(rename = "storeAvailable")]
95 pub store_available: i64,
96}
97
98#[derive(Debug, Clone, Default, Serialize, Deserialize)]
100pub struct SkillBrowseResponse {
101 pub items: Vec<SkillStoreItem>,
102 pub total: i64,
103 pub page: i64,
104 #[serde(rename = "pageSize")]
105 pub page_size: i64,
106}
107
108#[derive(Debug, Clone, Default, Serialize, Deserialize)]
111pub struct SkillStoreListItem {
112 pub id: String,
113 pub key: String,
114 pub name: String,
115 pub description: String,
116 pub icon: String,
117 pub category: String,
118 pub version: String,
119 pub author: String,
120 #[serde(rename = "downloadCount")]
121 pub download_count: i64,
122 pub tags: Vec<String>,
123 #[serde(
124 rename = "certificationStatus",
125 default,
126 skip_serializing_if = "Option::is_none"
127 )]
128 pub certification_status: Option<String>,
129 #[serde(default, skip_serializing_if = "Option::is_none")]
130 pub visibility: Option<String>,
131 #[serde(default, skip_serializing_if = "Option::is_none")]
132 pub source: Option<String>,
133 #[serde(rename = "updatedAt")]
134 pub updated_at: String,
135}
136
137#[derive(Debug, Clone, Default, Serialize, Deserialize)]
139pub struct SkillBrowseListResponse {
140 pub items: Vec<SkillStoreListItem>,
141 pub total: i64,
142 pub page: i64,
143 #[serde(rename = "pageSize")]
144 pub page_size: i64,
145}
146
147#[derive(Debug, Clone, Default, Serialize, Deserialize)]
149pub struct CertificationStatus {
150 #[serde(rename = "skillId")]
151 pub skill_id: String,
152 #[serde(rename = "certificationStatus")]
153 pub certification_status: String,
154 #[serde(
155 rename = "certifiedAt",
156 default,
157 skip_serializing_if = "Option::is_none"
158 )]
159 pub certified_at: Option<i64>,
160 #[serde(
161 rename = "securityLevel",
162 default,
163 skip_serializing_if = "Option::is_none"
164 )]
165 pub security_level: Option<String>,
166 #[serde(rename = "securityScore")]
167 pub security_score: i64,
168 #[serde(default, skip_serializing_if = "Option::is_none")]
169 pub report: Option<serde_json::Value>,
170}
171
172#[derive(Debug, Clone, Default, Serialize, Deserialize)]
178pub struct GenerateSkillRequest {
179 pub purpose: String,
180 #[serde(default, skip_serializing_if = "Option::is_none")]
181 pub examples: Option<Vec<String>>,
182 #[serde(
183 rename = "inputHints",
184 default,
185 skip_serializing_if = "Option::is_none"
186 )]
187 pub input_hints: Option<String>,
188 #[serde(
189 rename = "outputHints",
190 default,
191 skip_serializing_if = "Option::is_none"
192 )]
193 pub output_hints: Option<String>,
194 #[serde(default, skip_serializing_if = "Option::is_none")]
195 pub category: Option<String>,
196 #[serde(default, skip_serializing_if = "Option::is_none")]
197 pub language: Option<String>,
198}
199
200#[derive(Debug, Clone, Default, Serialize, Deserialize)]
202pub struct GenerateSkillResult {
203 #[serde(rename = "skillName")]
204 pub skill_name: String,
205 #[serde(rename = "skillKey")]
206 pub skill_key: String,
207 pub description: String,
208 #[serde(rename = "skillMd")]
209 pub skill_md: String,
210 #[serde(rename = "inputSchema")]
211 pub input_schema: String,
212 #[serde(rename = "outputSchema")]
213 pub output_schema: String,
214 #[serde(rename = "testCases")]
215 pub test_cases: Vec<String>,
216 pub readme: String,
217 pub category: String,
218 pub tags: Vec<String>,
219 pub timeout: i64,
220}
221
222#[derive(Debug, Clone, Default, Serialize, Deserialize)]
224pub struct OptimizeSkillRequest {
225 #[serde(rename = "skillName")]
226 pub skill_name: String,
227 #[serde(default, skip_serializing_if = "Option::is_none")]
228 pub description: Option<String>,
229 #[serde(
230 rename = "inputSchema",
231 default,
232 skip_serializing_if = "Option::is_none"
233 )]
234 pub input_schema: Option<String>,
235 #[serde(
236 rename = "outputSchema",
237 default,
238 skip_serializing_if = "Option::is_none"
239 )]
240 pub output_schema: Option<String>,
241 #[serde(default, skip_serializing_if = "Option::is_none")]
242 pub readme: Option<String>,
243 #[serde(default, skip_serializing_if = "Option::is_none")]
244 pub aspects: Option<Vec<String>>,
245}
246
247#[derive(Debug, Clone, Default, Serialize, Deserialize)]
249pub struct OptimizeSkillResult {
250 #[serde(rename = "optimizedSkill")]
251 pub optimized_skill: GenerateSkillResult,
252 pub changes: Vec<String>,
253 pub score: f64,
254}
255
256#[derive(Debug, Clone, Default, Serialize, Deserialize)]
262pub struct ToolView {
263 pub id: String,
264 pub key: String,
265 pub name: String,
266 pub description: String,
267 pub icon: String,
268 pub category: String,
269 #[serde(rename = "inputSchema")]
270 pub input_schema: String,
271 #[serde(rename = "outputSchema")]
272 pub output_schema: String,
273 pub timeout: i64,
274 #[serde(rename = "isEnabled")]
275 pub is_enabled: bool,
276 #[serde(default, skip_serializing_if = "Option::is_none")]
277 pub provider: Option<ToolProvider>,
278}
279
280#[derive(Debug, Clone, Default, Serialize, Deserialize)]
282pub struct ToolProvider {
283 pub id: String,
284 pub name: String,
285 pub icon: String,
286 #[serde(rename = "sourceType")]
287 pub source_type: String,
288 #[serde(
289 rename = "mcpEndpoint",
290 default,
291 skip_serializing_if = "Option::is_none"
292 )]
293 pub mcp_endpoint: Option<String>,
294 #[serde(rename = "isEnabled")]
295 pub is_enabled: bool,
296}
297
298#[derive(Debug, Clone, Default, Serialize, Deserialize)]
300pub struct ToolListResponse {
301 pub skills: Vec<ToolView>,
302 pub total: i64,
303}
304
305#[cfg(test)]
306mod tests {
307 use super::*;
308
309 #[test]
310 fn skill_store_item_round_trip() {
311 let json = r#"{"id":"s1","pluginId":"p1","key":"k","name":"N","description":"D","icon":"i","category":"CODING","inputSchema":"{}","outputSchema":"{}","timeout":30,"retryCount":1,"retryDelay":100,"version":"1.0.0","totalCalls":10,"avgDurationMs":200,"successRate":0.99,"isEnabled":true,"securityLevel":"LOW","securityScore":80,"scope":"TENANT","status":"ACTIVE","downloadCount":5,"tags":["a"],"author":"me","publisherId":"pub","isPublished":true,"pluginName":"pn","pluginIcon":"pi","updatedAt":"2026-06-19T00:00:00Z"}"#;
312 let item: SkillStoreItem = serde_json::from_str(json).unwrap();
313 assert_eq!(item.id, "s1");
314 assert_eq!(item.success_rate, 0.99);
315 assert!(item.is_enabled);
316 assert_eq!(item.readme, None);
317 let back: SkillStoreItem =
319 serde_json::from_str(&serde_json::to_string(&item).unwrap()).unwrap();
320 assert_eq!(back.download_count, 5);
321 }
322}