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
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

//! Repository for declared agent services (named processes registered with the
//! platform).
//!
//! The `services` table belongs to `systemprompt-database`; this adapter keeps
//! the agent vocabulary (register, mark running/stopped/error) and delegates
//! every statement to [`ServiceRepository`].
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

use systemprompt_database::{DbPool, ServiceRepository, UpsertServiceProcessInput};
use systemprompt_identifiers::{AgentName, InstanceId, ServiceName};
use systemprompt_manifest::services::{ServiceModule, ServiceStatus};
use systemprompt_traits::RepositoryError;

#[derive(Debug)]
pub struct AgentServiceRow {
    pub name: AgentName,
    pub pid: Option<i32>,
    pub port: i32,
    pub status: ServiceStatus,
}

#[derive(Debug)]
pub struct AgentServerIdRow {
    pub name: AgentName,
}

#[derive(Debug, Clone)]
pub struct AgentServiceRepository {
    services: ServiceRepository,
}

impl AgentServiceRepository {
    pub fn new(db: &DbPool, instance_id: InstanceId) -> Self {
        let services = ServiceRepository::new(db, instance_id);
        Self { services }
    }

    pub async fn register_agent(
        &self,
        name: &AgentName,
        pid: u32,
        port: u16,
    ) -> Result<(), RepositoryError> {
        self.register_process(name, pid, port, ServiceStatus::Running)
            .await
    }

    pub async fn register_agent_starting(
        &self,
        name: &AgentName,
        pid: u32,
        port: u16,
    ) -> Result<(), RepositoryError> {
        self.register_process(name, pid, port, ServiceStatus::Starting)
            .await
    }

    async fn register_process(
        &self,
        name: &AgentName,
        pid: u32,
        port: u16,
        status: ServiceStatus,
    ) -> Result<(), RepositoryError> {
        self.remove_agent_service(name).await?;
        self.services
            .upsert_service_process(UpsertServiceProcessInput {
                name: &ServiceName::of_agent(name),
                module_name: ServiceModule::Agent,
                pid: db_pid(pid)?,
                port,
                status,
            })
            .await?;
        Ok(())
    }

    pub async fn mark_running(&self, agent_name: &AgentName) -> Result<(), RepositoryError> {
        self.services
            .update_service_status(&ServiceName::of_agent(agent_name), ServiceStatus::Running)
            .await?;
        Ok(())
    }

    pub async fn find_agent_status(
        &self,
        agent_name: &AgentName,
    ) -> Result<Option<AgentServiceRow>, RepositoryError> {
        let Some(row) = self
            .services
            .find_service_by_name(&ServiceName::of_agent(agent_name))
            .await?
        else {
            return Ok(None);
        };
        if row.module_name != ServiceModule::Agent {
            return Ok(None);
        }
        Ok(Some(AgentServiceRow {
            status: row.status,
            name: AgentName::new(row.name.as_str()),
            pid: row.pid,
            port: row.port,
        }))
    }

    pub async fn mark_stopped(&self, agent_name: &AgentName) -> Result<(), RepositoryError> {
        self.services
            .update_service_stopped(&ServiceName::of_agent(agent_name))
            .await?;
        Ok(())
    }

    pub async fn mark_error(&self, agent_name: &AgentName) -> Result<(), RepositoryError> {
        self.services
            .mark_service_crashed(&ServiceName::of_agent(agent_name))
            .await?;
        Ok(())
    }

    pub async fn list_running_agents(&self) -> Result<Vec<AgentServerIdRow>, RepositoryError> {
        let rows = self
            .services
            .list_running_services_by_module(ServiceModule::Agent)
            .await?;
        Ok(rows
            .into_iter()
            .map(|r| AgentServerIdRow {
                name: AgentName::new(r.name.as_str()),
            })
            .collect())
    }

    pub async fn remove_agent_service(
        &self,
        agent_name: &AgentName,
    ) -> Result<(), RepositoryError> {
        self.services
            .delete_service(&ServiceName::of_agent(agent_name))
            .await?;
        Ok(())
    }
}

fn db_pid(pid: u32) -> Result<i32, RepositoryError> {
    i32::try_from(pid).map_err(|_overflow| {
        RepositoryError::invalid_data("services.pid", format!("{pid} exceeds the column range"))
    })
}