procyon 0.3.0

Terminal development harness for Stellar and Soroban smart contracts, driven by a language model
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

use async_trait::async_trait;
use serde_json::{json, Value};

use super::Tool;
use crate::party::{self, PartyConfig};

/// Tool: party_mode
///
/// Runs a multi-agent discussion with multiple personas in parallel.
/// Each persona runs as an independent sub-agent and returns their perspective.
pub struct PartyModeTool;

#[async_trait]
impl Tool for PartyModeTool {
    fn name(&self) -> &str {
        "party_mode"
    }

    fn capability(&self) -> crate::risk::Capability {
        crate::risk::Capability::Delegating
    }

    fn description(&self) -> &str {
        "Run a multi-agent roundtable discussion. Multiple personas (Tyler, Elliot, Nicole, etc.) \
         respond in parallel, each from their own perspective. Use when the user wants multiple \
         opinions, a group discussion, or 'party mode'."
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "message": {
                    "type": "string",
                    "description": "The topic or question for the roundtable"
                },
                "personas": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Optional list of persona names/skills to include. If omitted, all available personas participate."
                },
                "model": {
                    "type": "string",
                    "description": "Optional model override for all sub-agents"
                }
            },
            "required": ["message"]
        })
    }

    async fn execute(&self, input: Value) -> Result<String, String> {
        let message = input
            .get("message")
            .and_then(|v| v.as_str())
            .ok_or_else(|| "Missing 'message' field".to_string())?
            .to_string();

        let personas = input.get("personas").and_then(|v| v.as_array()).map(|arr| {
            arr.iter()
                .filter_map(|v| v.as_str().map(|s| s.to_string()))
                .collect::<Vec<_>>()
        });

        let model = input
            .get("model")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());

        let config = crate::config::AppConfig::load().unwrap_or_default();

        let party_config = PartyConfig {
            message,
            personas,
            model,
            timeout: None, // use default 120s
        };

        let responses = party::run_party(&config, party_config).await;

        Ok(party::format_responses(&responses))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::tools::ToolRegistry;

    #[test]
    fn party_mode_tool_has_correct_name() {
        let tool = PartyModeTool;
        assert_eq!(tool.name(), "party_mode");
    }

    #[test]
    fn party_mode_schema_requires_message() {
        let tool = PartyModeTool;
        let schema = tool.input_schema();
        let required = schema["required"].as_array().unwrap();
        assert!(required.contains(&json!("message")));
    }

    #[test]
    fn party_mode_schema_has_optional_fields() {
        let tool = PartyModeTool;
        let schema = tool.input_schema();
        let props = schema["properties"].as_object().unwrap();
        assert!(props.contains_key("personas"));
        assert!(props.contains_key("model"));
    }

    #[tokio::test]
    async fn party_mode_rejects_missing_message() {
        let tool = PartyModeTool;
        let err = tool.execute(json!({})).await.unwrap_err();
        assert!(err.contains("Missing"), "got: {}", err);
    }

    #[tokio::test]
    async fn party_mode_tool_is_callable() {
        let tool = PartyModeTool;
        assert!(!tool.description().is_empty());
    }

    #[tokio::test]
    async fn party_mode_register_in_registry() {
        let mut registry = ToolRegistry::new();
        registry.register(Box::new(PartyModeTool));
        assert!(registry.get_tool("party_mode").is_some());
    }
}