imitatort 0.0.1-SNAPSHOT-dev.20260302111239

轻量级多Agent公司模拟框架
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

//! Skill Domain Entity
//!
//! Core business definition for skill system, supporting many-to-many binding between skills and tools

use serde::{Deserialize, Serialize};

/// Skill Entity
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Skill {
    pub id: String,
    pub name: String,
    pub description: String,
    pub category: String,
    pub version: String,
    pub author: String,
    pub metadata: std::collections::HashMap<String, serde_json::Value>, // Extended metadata
}

impl Skill {
    /// Create new skill
    pub fn new(
        id: impl Into<String>,
        name: impl Into<String>,
        description: impl Into<String>,
        category: impl Into<String>,
        version: impl Into<String>,
        author: impl Into<String>,
    ) -> Self {
        Self {
            id: id.into(),
            name: name.into(),
            description: description.into(),
            category: category.into(),
            version: version.into(),
            author: author.into(),
            metadata: std::collections::HashMap::new(),
        }
    }

    /// Set metadata
    pub fn with_metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
        self.metadata.insert(key.into(), value);
        self
    }
}

/// Relationship between Skill and Tool
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkillToolBinding {
    pub skill_id: String,
    pub tool_id: String,
    pub binding_type: BindingType,
    pub metadata: std::collections::HashMap<String, serde_json::Value>,
}

impl SkillToolBinding {
    /// Create new binding
    pub fn new(
        skill_id: impl Into<String>,
        tool_id: impl Into<String>,
        binding_type: BindingType,
    ) -> Self {
        Self {
            skill_id: skill_id.into(),
            tool_id: tool_id.into(),
            binding_type,
            metadata: std::collections::HashMap::new(),
        }
    }

    /// Set binding metadata
    pub fn with_metadata(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
        self.metadata.insert(key.into(), value);
        self
    }
}

/// Binding Type
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum BindingType {
    /// Required binding: Skill must have this tool to work properly
    Required,
    /// Optional binding: Skill can enhance functionality using this tool
    Optional,
}

/// Tool Access Type
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ToolAccessType {
    /// Public tool: Anyone can call
    Public,
    /// Private tool: Requires specific skill to call
    Private,
}