systemprompt-cli 0.1.22

systemprompt.io OS - CLI for agent orchestration, AI operations, and system management
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

use anyhow::{Result, anyhow};
use clap::Args;
use systemprompt_models::services::AgentConfig;

#[derive(Debug, Args, Default, Clone)]
pub struct AgentArgs {
    #[arg(long, help = "Port for the agent")]
    pub port: Option<u16>,

    #[arg(long, help = "Custom endpoint path (default: /api/v1/agents/{name})")]
    pub endpoint: Option<String>,

    #[arg(long, help = "Mark agent as dev-only (won't run in production)")]
    pub dev_only: bool,

    #[arg(long, help = "Mark agent as primary")]
    pub is_primary: bool,

    #[arg(long, help = "Mark agent as the default agent")]
    pub default: bool,

    #[arg(long, help = "Display name for the agent")]
    pub display_name: Option<String>,

    #[arg(long, help = "Description of the agent")]
    pub description: Option<String>,

    #[arg(long, help = "Version string for the agent (default: 1.0.0)")]
    pub version: Option<String>,

    #[arg(long, help = "URL to the agent's icon")]
    pub icon_url: Option<String>,

    #[arg(long, help = "URL to the agent's documentation")]
    pub documentation_url: Option<String>,

    #[arg(long, help = "Enable streaming capability (default: true)")]
    pub streaming: Option<bool>,

    #[arg(long, help = "Enable push notifications capability")]
    pub push_notifications: Option<bool>,

    #[arg(long, help = "Enable state transition history (default: true)")]
    pub state_transition_history: Option<bool>,

    #[arg(long, help = "AI provider (e.g., anthropic, openai, gemini)")]
    pub provider: Option<String>,

    #[arg(long, help = "AI model (e.g., claude-3-5-sonnet-20241022)")]
    pub model: Option<String>,

    #[arg(long = "system-prompt", help = "Set the system prompt inline")]
    pub system_prompt: Option<String>,

    #[arg(long = "system-prompt-file", help = "Load system prompt from a file")]
    pub system_prompt_file: Option<String>,

    #[arg(
        long = "mcp-server",
        help = "Add an MCP server reference (can be specified multiple times)"
    )]
    pub mcp_servers: Vec<String>,

    #[arg(
        long = "skill",
        help = "Add a skill reference (can be specified multiple times)"
    )]
    pub skills: Vec<String>,
}

impl AgentArgs {
    pub fn has_any_value(&self) -> bool {
        self.port.is_some()
            || self.endpoint.is_some()
            || self.dev_only
            || self.is_primary
            || self.default
            || self.display_name.is_some()
            || self.description.is_some()
            || self.version.is_some()
            || self.icon_url.is_some()
            || self.documentation_url.is_some()
            || self.streaming.is_some()
            || self.push_notifications.is_some()
            || self.state_transition_history.is_some()
            || self.provider.is_some()
            || self.model.is_some()
            || self.system_prompt.is_some()
            || self.system_prompt_file.is_some()
            || !self.mcp_servers.is_empty()
            || !self.skills.is_empty()
    }
}

pub fn apply_set_value(agent: &mut AgentConfig, key: &str, value: &str) -> Result<()> {
    match key {
        "card.displayName" | "card.display_name" => {
            agent.card.display_name = value.to_string();
        },
        "card.description" => {
            agent.card.description = value.to_string();
        },
        "card.version" => {
            agent.card.version = value.to_string();
        },
        "endpoint" => {
            agent.endpoint = value.to_string();
        },
        "is_primary" => {
            agent.is_primary = value
                .parse()
                .map_err(|_| anyhow!("Invalid boolean value for is_primary: '{}'", value))?;
        },
        "default" => {
            agent.default = value
                .parse()
                .map_err(|_| anyhow!("Invalid boolean value for default: '{}'", value))?;
        },
        "dev_only" => {
            agent.dev_only = value
                .parse()
                .map_err(|_| anyhow!("Invalid boolean value for dev_only: '{}'", value))?;
        },
        _ => {
            return Err(anyhow!(
                "Unknown configuration key: '{}'. Supported keys: card.displayName, \
                 card.description, card.version, endpoint, is_primary, default, dev_only",
                key
            ));
        },
    }
    Ok(())
}