systemprompt-agent 0.2.0

Core Agent protocol module for systemprompt.io
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

//! Implementation of `AgentRegistryProvider` trait for the agent module.

use async_trait::async_trait;
use systemprompt_traits::{AgentInfo, AgentRegistryProvider, RegistryError, ServiceOAuthConfig};

use super::registry::AgentRegistry;

#[derive(Debug, Clone)]
pub struct AgentRegistryProviderService {
    registry: AgentRegistry,
}

impl AgentRegistryProviderService {
    pub fn new() -> Result<Self, RegistryError> {
        let registry =
            AgentRegistry::new().map_err(|e| RegistryError::Unavailable(e.to_string()))?;

        Ok(Self { registry })
    }

    pub const fn from_registry(registry: AgentRegistry) -> Self {
        Self { registry }
    }
}

#[async_trait]
impl AgentRegistryProvider for AgentRegistryProviderService {
    async fn get_agent(&self, name: &str) -> Result<AgentInfo, RegistryError> {
        let agent = self
            .registry
            .get_agent(name)
            .await
            .map_err(|e| RegistryError::NotFound(e.to_string()))?;

        Ok(AgentInfo {
            name: agent.name,
            port: agent.port,
            enabled: agent.enabled,
            oauth: ServiceOAuthConfig {
                required: agent.oauth.required,
                scopes: agent.oauth.scopes.iter().map(ToString::to_string).collect(),
                audience: agent.oauth.audience.to_string(),
            },
        })
    }

    async fn list_enabled_agents(&self) -> Result<Vec<AgentInfo>, RegistryError> {
        let agents = self
            .registry
            .list_enabled_agents()
            .await
            .map_err(|e| RegistryError::Unavailable(e.to_string()))?;

        Ok(agents
            .into_iter()
            .map(|agent| AgentInfo {
                name: agent.name,
                port: agent.port,
                enabled: agent.enabled,
                oauth: ServiceOAuthConfig {
                    required: agent.oauth.required,
                    scopes: agent.oauth.scopes.iter().map(ToString::to_string).collect(),
                    audience: agent.oauth.audience.to_string(),
                },
            })
            .collect())
    }

    async fn get_default_agent(&self) -> Result<AgentInfo, RegistryError> {
        let agent = self
            .registry
            .get_default_agent()
            .await
            .map_err(|e| RegistryError::NotFound(e.to_string()))?;

        Ok(AgentInfo {
            name: agent.name,
            port: agent.port,
            enabled: agent.enabled,
            oauth: ServiceOAuthConfig {
                required: agent.oauth.required,
                scopes: agent.oauth.scopes.iter().map(ToString::to_string).collect(),
                audience: agent.oauth.audience.to_string(),
            },
        })
    }
}