systemprompt-agent 0.63.0

Agent-to-Agent (A2A) protocol for systemprompt.io AI governance: streaming, JSON-RPC models, task lifecycle, .well-known discovery, and governed agent orchestration.
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

//! Implementation of `AgentRegistryProvider` trait for the agent module.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

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

use super::registry::AgentRegistry;
use crate::error::AgentError;

#[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.into()))?;

        Ok(Self { registry })
    }

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

impl AgentRegistryProvider for AgentRegistryProviderService {
    async fn get_agent(&self, name: &str) -> Result<AgentInfo, RegistryError> {
        let agent = self
            .registry
            .get_agent(name)
            .await
            .map_err(registry_error)?;

        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(),
                ema: false,
            },
        })
    }

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

        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(),
                    ema: false,
                },
            })
            .collect())
    }

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

        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(),
                ema: false,
            },
        })
    }
}

fn registry_error(error: AgentError) -> RegistryError {
    match error {
        AgentError::NotFound(name) => RegistryError::NotFound(name),
        AgentError::EmptyCorsAllowlist
        | AgentError::InvalidConfig { .. }
        | AgentError::ServicesConfig(_) => RegistryError::Configuration(error.into()),
        other => RegistryError::Unavailable(other.into()),
    }
}