crabtalk-runtime 0.0.17

Crabtalk agent runtime — tool dispatch, MCP, skills, and memory
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

//! Tool dispatch and schema registration for the skill tool.

use crate::{Env, host::Host, skill::loader};
use serde::Deserialize;
use wcore::{
    agent::{AsTool, ToolDescription},
    model::Tool,
};

#[derive(Deserialize, schemars::JsonSchema)]
pub struct Skill {
    /// Skill name to load. If no exact match, returns fuzzy matches.
    /// Leave empty to list all available skills.
    pub name: String,
}

impl ToolDescription for Skill {
    const DESCRIPTION: &'static str = "Load a skill by name. Returns its instructions on exact match, or lists matching skills otherwise.";
}

pub fn tools() -> Vec<Tool> {
    vec![Skill::as_tool()]
}

impl<H: Host> Env<H> {
    pub async fn dispatch_skill(&self, args: &str, agent: &str) -> String {
        let input: Skill = match serde_json::from_str(args) {
            Ok(v) => v,
            Err(e) => return format!("invalid arguments: {e}"),
        };
        let name = &input.name;

        // Enforce skill scope.
        if let Some(scope) = self.scopes.get(agent)
            && !scope.skills.is_empty()
            && !scope.skills.iter().any(|s| s == name)
        {
            return format!("skill not available: {name}");
        }

        // Guard against path traversal.
        if name.contains("..") || name.contains('/') || name.contains('\\') {
            return format!("invalid skill name: {name}");
        }

        // Try exact load from each skill directory.
        if !name.is_empty() {
            for dir in &self.skills.skill_dirs {
                let skill_dir = dir.join(name);
                let skill_file = skill_dir.join("SKILL.md");
                if let Ok(content) = tokio::fs::read_to_string(&skill_file).await {
                    return match loader::parse_skill_md(&content) {
                        Ok(skill) => {
                            let body = skill.body.clone();
                            self.skills.registry.lock().await.upsert(skill);
                            let dir_path = skill_dir.display();
                            format!("{body}\n\nSkill directory: {dir_path}")
                        }
                        Err(e) => format!("failed to parse skill: {e}"),
                    };
                }
            }
        }

        // No exact match — fuzzy search / list all.
        let query = name.to_lowercase();
        let allowed = self.scopes.get(agent).map(|s| &s.skills);
        let registry = self.skills.registry.lock().await;
        let matches: Vec<String> = registry
            .skills
            .iter()
            .filter(|s| {
                if let Some(allowed) = allowed
                    && !allowed.is_empty()
                    && !allowed.iter().any(|a| a == s.name.as_str())
                {
                    return false;
                }
                query.is_empty()
                    || s.name.to_lowercase().contains(&query)
                    || s.description.to_lowercase().contains(&query)
            })
            .map(|s| format!("{}: {}", s.name, s.description))
            .collect();

        if matches.is_empty() {
            "no skills found".to_owned()
        } else {
            matches.join("\n")
        }
    }
}