rsclaw 0.0.1-alpha.1

rsclaw: High-performance AI agent (BETA). Optimized for M4 Max and 2GB VPS. 100% compatible with openclaw
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 super::engine::HookEngine;
use super::types::{HookContext, HookEvent, HookResult};
use serde_json::Value;
use std::sync::Arc;

/// Event trigger for dispatching events to the hook engine.
pub struct HookTrigger {
    engine: Arc<HookEngine>,
}

impl HookTrigger {
    /// Create a new hook trigger.
    pub fn new(engine: Arc<HookEngine>) -> Self {
        Self { engine }
    }

    /// Trigger an event.
    pub async fn trigger(&self, event: HookEvent, data: Value) -> Vec<HookResult> {
        let context = HookContext::new(event, data);

        match self.engine.execute(&context).await {
            Ok(results) => results,
            Err(e) => {
                tracing::error!("Hook execution error: {}", e);
                Vec::new()
            }
        }
    }

    /// Trigger system_start event.
    pub async fn system_start(&self) -> Vec<HookResult> {
        self.trigger(HookEvent::SystemStart, Value::Null).await
    }

    /// Trigger config_loaded event.
    pub async fn config_loaded(&self, config: &crate::config::runtime::RuntimeConfig) -> Vec<HookResult> {
        let data = serde_json::json!({
            "gateway_host": config.gateway.host.to_string(),
            "gateway_port": config.gateway.port,
        });
        self.trigger(HookEvent::ConfigLoaded, data).await
    }

    /// Trigger gateway_start event.
    pub async fn gateway_start(&self, host: &str, port: u16) -> Vec<HookResult> {
        let data = serde_json::json!({
            "host": host,
            "port": port,
        });
        self.trigger(HookEvent::GatewayStart, data).await
    }

    /// Trigger agent_create event.
    pub async fn agent_create(&self, agent_name: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "agent_name": agent_name,
        });
        self.trigger(HookEvent::AgentCreate, data).await
    }

    /// Trigger agent_chat event.
    pub async fn agent_chat(&self, agent_name: &str, message: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "agent_name": agent_name,
            "message": message,
        });
        self.trigger(HookEvent::AgentChat, data).await
    }

    /// Trigger agent_destroy event.
    pub async fn agent_destroy(&self, agent_name: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "agent_name": agent_name,
        });
        self.trigger(HookEvent::AgentDestroy, data).await
    }

    /// Trigger skill_loaded event.
    pub async fn skill_loaded(&self, skill_name: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "skill_name": skill_name,
        });
        self.trigger(HookEvent::SkillLoaded, data).await
    }

    /// Trigger skill_run_start event.
    pub async fn skill_run_start(&self, skill_name: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "skill_name": skill_name,
        });
        self.trigger(HookEvent::SkillRunStart, data).await
    }

    /// Trigger skill_run_end event.
    pub async fn skill_run_end(&self, skill_name: &str, success: bool) -> Vec<HookResult> {
        let data = serde_json::json!({
            "skill_name": skill_name,
            "success": success,
        });
        self.trigger(HookEvent::SkillRunEnd, data).await
    }

    /// Trigger cron_job_execute event.
    pub async fn cron_job_execute(&self, job_id: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "job_id": job_id,
        });
        self.trigger(HookEvent::CronJobExecute, data).await
    }

    /// Trigger message_received event.
    pub async fn message_received(&self, channel: &str, session_id: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "channel": channel,
            "session_id": session_id,
        });
        self.trigger(HookEvent::MessageReceived, data).await
    }

    /// Trigger message_sent event.
    pub async fn message_sent(&self, channel: &str, session_id: &str) -> Vec<HookResult> {
        let data = serde_json::json!({
            "channel": channel,
            "session_id": session_id,
        });
        self.trigger(HookEvent::MessageSent, data).await
    }
}