openclaw-plugins 0.1.0

Plugin system and FFI bridge for 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

//! Plugin API.

use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use thiserror::Error;

/// Plugin errors.
#[derive(Error, Debug)]
pub enum PluginError {
    /// Plugin not found.
    #[error("Plugin not found: {0}")]
    NotFound(String),

    /// Plugin load failed.
    #[error("Load failed: {0}")]
    LoadFailed(String),

    /// Hook execution failed.
    #[error("Hook failed: {0}")]
    HookFailed(String),

    /// General execution error.
    #[error("Execution error: {0}")]
    ExecutionError(String),

    /// IPC error.
    #[error("IPC error: {0}")]
    Ipc(String),
}

/// Plugin lifecycle hooks.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PluginHook {
    /// Before agent processes message.
    BeforeMessage,
    /// After agent processes message.
    AfterMessage,
    /// Before tool execution.
    BeforeToolCall,
    /// After tool execution.
    AfterToolCall,
    /// Session started.
    SessionStart,
    /// Session ended.
    SessionEnd,
    /// Agent response generated.
    AgentResponse,
    /// Error occurred.
    Error,
}

/// Plugin trait.
#[async_trait]
pub trait Plugin: Send + Sync {
    /// Plugin ID.
    fn id(&self) -> &str;

    /// Plugin name.
    fn name(&self) -> &str;

    /// Plugin version.
    fn version(&self) -> &str;

    /// Supported hooks.
    fn hooks(&self) -> &[PluginHook];

    /// Execute a hook.
    async fn execute_hook(
        &self,
        hook: PluginHook,
        data: serde_json::Value,
    ) -> Result<serde_json::Value, PluginError>;

    /// Activate the plugin.
    async fn activate(&self) -> Result<(), PluginError>;

    /// Deactivate the plugin.
    async fn deactivate(&self) -> Result<(), PluginError>;
}

/// Plugin API exposed to plugins.
pub struct PluginApi {
    // Context available to plugins
}

impl PluginApi {
    /// Create a new plugin API.
    #[must_use]
    pub const fn new() -> Self {
        Self {}
    }
}

impl Default for PluginApi {
    fn default() -> Self {
        Self::new()
    }
}