wm-tools 9.1.2

Curated tool implementations for the WhiteMagic MCP server.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Sandbox tools — `sandbox.set_limits`, `sandbox.limits`.
//!
//! Runtime tuning of the resource-limit layer (per-minute write / spawn /
//! network budgets, novelty thresholds, human-review requirement). Ports
//! the v26 `sandbox.set_limits` surface onto the v5 `ResourceRules`
//! config, which the dispatch pipeline reads on every evaluation.

#![forbid(unsafe_code)]

use async_trait::async_trait;

use serde_json::{Value, json};
use std::sync::Arc;
use wm_core::{Context, EffectRow, Gana, Resource, Tool, ToolStats};
use wm_governance::ResourceRules;

/// `sandbox.set_limits` — update resource limits at runtime.
pub struct SandboxSetLimitsTool {
    rules: Arc<ResourceRules>,
    stats: ToolStats,
    effects: EffectRow,
}

impl SandboxSetLimitsTool {
    #[must_use]
    pub fn new(rules: Arc<ResourceRules>) -> Self {
        Self {
            rules,
            stats: ToolStats::default(),
            effects: EffectRow {
                writes: vec![Resource::DharmaRules],
                ..Default::default()
            },
        }
    }
}

#[async_trait]
impl Tool for SandboxSetLimitsTool {
    fn name(&self) -> &str {
        "sandbox.set_limits"
    }
    fn gana(&self) -> Gana {
        Gana::Room
    }
    fn effects(&self) -> &EffectRow {
        &self.effects
    }
    fn description(&self) -> &str {
        "Update sandbox resource limits at runtime: max_writes_per_minute, max_spawns_per_minute, max_network_per_minute, novelty_window, max_repeats, require_human_review. All fields optional — provided ones are applied, others keep current values."
    }
    async fn call(&self, _ctx: &mut Context, args: Value) -> wm_core::Result<Value> {
        let mut cfg = self.rules.config();
        let mut changed: Vec<&'static str> = Vec::new();
        if let Some(v) = args.get("max_writes_per_minute").and_then(Value::as_u64) {
            cfg.max_writes_per_minute = v as u32;
            changed.push("max_writes_per_minute");
        }
        if let Some(v) = args.get("max_spawns_per_minute").and_then(Value::as_u64) {
            cfg.max_spawns_per_minute = v as u32;
            changed.push("max_spawns_per_minute");
        }
        if let Some(v) = args.get("max_network_per_minute").and_then(Value::as_u64) {
            cfg.max_network_per_minute = v as u32;
            changed.push("max_network_per_minute");
        }
        if let Some(v) = args.get("novelty_window").and_then(Value::as_u64) {
            cfg.novelty_window = v as usize;
            changed.push("novelty_window");
        }
        if let Some(v) = args.get("max_repeats").and_then(Value::as_u64) {
            cfg.max_repeats = v as u32;
            changed.push("max_repeats");
        }
        if let Some(v) = args.get("require_human_review").and_then(Value::as_bool) {
            cfg.require_human_review = v;
            changed.push("require_human_review");
        }
        self.rules.set_config(cfg);
        let cfg = self.rules.config();
        Ok(json!({
            "status": "success",
            "changed": changed,
            "limits": {
                "max_writes_per_minute": cfg.max_writes_per_minute,
                "max_spawns_per_minute": cfg.max_spawns_per_minute,
                "max_network_per_minute": cfg.max_network_per_minute,
                "novelty_window": cfg.novelty_window,
                "max_repeats": cfg.max_repeats,
                "require_human_review": cfg.require_human_review,
            },
        }))
    }
    fn stats(&self) -> &ToolStats {
        &self.stats
    }
}

/// `sandbox.limits` — show the current sandbox limits.
pub struct SandboxLimitsTool {
    rules: Arc<ResourceRules>,
    stats: ToolStats,
    effects: EffectRow,
}

impl SandboxLimitsTool {
    #[must_use]
    pub fn new(rules: Arc<ResourceRules>) -> Self {
        Self {
            rules,
            stats: ToolStats::default(),
            effects: EffectRow::read_only(vec![Resource::DharmaRules]),
        }
    }
}

#[async_trait]
impl Tool for SandboxLimitsTool {
    fn name(&self) -> &str {
        "sandbox.limits"
    }
    fn gana(&self) -> Gana {
        Gana::Room
    }
    fn effects(&self) -> &EffectRow {
        &self.effects
    }
    fn description(&self) -> &str {
        "Show the current sandbox resource limits"
    }
    async fn call(&self, _ctx: &mut Context, _args: Value) -> wm_core::Result<Value> {
        let cfg = self.rules.config();
        Ok(json!({
            "status": "success",
            "limits": {
                "max_writes_per_minute": cfg.max_writes_per_minute,
                "max_spawns_per_minute": cfg.max_spawns_per_minute,
                "max_network_per_minute": cfg.max_network_per_minute,
                "novelty_window": cfg.novelty_window,
                "max_repeats": cfg.max_repeats,
                "require_human_review": cfg.require_human_review,
            },
        }))
    }
    fn stats(&self) -> &ToolStats {
        &self.stats
    }
}

/// Register the sandbox tools (2).
#[must_use]
pub fn register_sandbox(
    registry: &wm_dispatch::ToolRegistry,
    rules: Option<&Arc<ResourceRules>>,
) -> wm_dispatch::ToolRegistry {
    match rules {
        Some(rules) => registry
            .register(Arc::new(SandboxSetLimitsTool::new(rules.clone())))
            .register(Arc::new(SandboxLimitsTool::new(rules.clone()))),
        None => registry.clone(),
    }
}