systemprompt-agent 0.2.2

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

use anyhow::{Result, anyhow};
use systemprompt_database::DbPool;
use systemprompt_models::RequestContext;

use crate::models::a2a::{Message, Task};
use crate::repository::task::{TaskRepository, UpdateTaskAndSaveMessagesParams};
use crate::services::ArtifactPublishingService;
use crate::services::a2a_server::streaming::{
    broadcast_artifact_created, broadcast_task_completed,
};

pub struct PersistCompletedTaskParams<'a> {
    pub task: &'a Task,
    pub user_message: &'a Message,
    pub agent_message: &'a Message,
    pub context: &'a RequestContext,
    pub task_repo: &'a TaskRepository,
    pub db_pool: &'a DbPool,
    pub artifacts_already_published: bool,
}

pub async fn persist_completed_task(params: PersistCompletedTaskParams<'_>) -> Result<Task> {
    let PersistCompletedTaskParams {
        task,
        user_message,
        agent_message,
        context,
        task_repo,
        db_pool,
        artifacts_already_published,
    } = params;
    let updated_task = task_repo
        .update_task_and_save_messages(UpdateTaskAndSaveMessagesParams {
            task,
            user_message,
            agent_message,
            user_id: Some(context.user_id()),
            session_id: context.session_id(),
            trace_id: context.trace_id(),
        })
        .await
        .map_err(|e| anyhow!("Failed to update task and save messages: {}", e))?;

    if !artifacts_already_published {
        if let Some(ref artifacts) = task.artifacts {
            let publishing_service = ArtifactPublishingService::new(db_pool)?;
            for artifact in artifacts {
                publishing_service
                    .publish_from_a2a(artifact, &task.id, &task.context_id)
                    .await
                    .map_err(|e| anyhow!("Failed to publish artifact {}: {}", artifact.id, e))?;

                broadcast_artifact_created(
                    artifact,
                    &task.id,
                    &task.context_id,
                    context.user_id(),
                    context.auth_token().as_str(),
                )
                .await
                .map_err(|e| anyhow!("Failed to broadcast artifact {}: {}", artifact.id, e))?;
            }

            tracing::info!(
                task_id = %task.id,
                artifact_count = artifacts.len(),
                "Published artifacts for task"
            );
        }
    }

    tracing::info!(
        task_id = %task.id,
        context_id = %task.context_id,
        user_id = %context.user_id(),
        "Persisted task"
    );

    Ok(updated_task)
}

pub async fn broadcast_completion(task: &Task, context: &RequestContext) {
    broadcast_task_completed(task, context.user_id(), context.auth_token().as_str()).await;
}