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

use super::memory::ConcurrencyLimiter;
use super::runtime::{AgentConfig, AgentRuntime};
use crate::provider::LlmProvider;
use anyhow::Result;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

/// Agent manager for multi-agent scheduling.
pub struct AgentManager {
    agents: Arc<RwLock<HashMap<Arc<str>, Arc<AgentRuntime>>>>,
    limiter: ConcurrencyLimiter,
    provider: Option<Arc<dyn LlmProvider>>,
}

impl AgentManager {
    /// Create a new agent manager.
    pub fn new(max_concurrent: u32) -> Self {
        Self {
            agents: Arc::new(RwLock::new(HashMap::new())),
            limiter: ConcurrencyLimiter::new(max_concurrent),
            provider: None,
        }
    }

    /// Set the LLM provider.
    pub fn set_provider(&mut self, provider: Arc<dyn LlmProvider>) {
        self.provider = Some(provider);
    }

    /// Get the LLM provider.
    pub fn provider(&self) -> Option<Arc<dyn LlmProvider>> {
        self.provider.clone()
    }

    /// Create an agent.
    pub async fn create(&self, config: AgentConfig) -> Result<Arc<str>> {
        if !self.limiter.try_acquire() {
            anyhow::bail!(
                "Cannot create agent: concurrency limit reached ({}/{})",
                self.limiter.current(),
                self.limiter.max()
            );
        }

        let name = config.name.clone();
        let agent = Arc::new(AgentRuntime::new(config));

        {
            let mut agents = self.agents.write().await;
            agents.insert(name.clone(), agent);
        }

        tracing::info!("Agent '{}' created", name);
        Ok(name)
    }

    /// Get an agent by name.
    pub async fn get(&self, name: &str) -> Option<Arc<AgentRuntime>> {
        let agents = self.agents.read().await;
        agents.get(name).cloned()
    }

    /// List all agents.
    pub async fn list(&self) -> Vec<Arc<AgentRuntime>> {
        let agents = self.agents.read().await;
        agents.values().cloned().collect()
    }

    /// Destroy an agent.
    pub async fn destroy(&self, name: &str) -> Result<bool> {
        let mut agents = self.agents.write().await;
        if agents.remove(name).is_some() {
            self.limiter.release();
            tracing::info!("Agent '{}' destroyed", name);
            Ok(true)
        } else {
            Ok(false)
        }
    }

    /// Send message to an agent.
    pub async fn chat(&self, agent_name: &str, message: &str) -> Result<String> {
        let agent = self.get(agent_name).await
            .ok_or_else(|| anyhow::anyhow!("Agent '{}' not found", agent_name))?;

        let provider = self.provider.clone()
            .ok_or_else(|| anyhow::anyhow!("No LLM provider configured"))?;

        agent.chat(message, provider).await
    }

    /// Get agent count.
    pub async fn count(&self) -> usize {
        let agents = self.agents.read().await;
        agents.len()
    }

    /// Check if at capacity.
    pub fn is_at_capacity(&self) -> bool {
        self.limiter.is_at_capacity()
    }

    /// Get current concurrency.
    pub fn current_concurrency(&self) -> u64 {
        self.limiter.current()
    }

    /// Get max concurrency.
    pub fn max_concurrency(&self) -> u64 {
        self.limiter.max()
    }
}

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