systemprompt-agent 0.1.22

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

mod builders;
pub mod helpers;

pub use builders::{
    build_canceled_task, build_completed_task, build_mock_task, build_multiturn_task,
    build_submitted_task,
};

use crate::models::a2a::{Artifact, Message, MessageRole, Part, Task, TaskState, TaskStatus, TextPart};
use systemprompt_identifiers::{ContextId, MessageId, TaskId};
use systemprompt_models::a2a::TaskMetadata;

#[derive(Debug)]
pub struct TaskBuilder {
    task_id: TaskId,
    context_id: ContextId,
    state: TaskState,
    response_text: String,
    id: MessageId,
    user_message: Option<Message>,
    artifacts: Vec<Artifact>,
    metadata: Option<TaskMetadata>,
}

impl TaskBuilder {
    pub fn new(context_id: ContextId) -> Self {
        Self {
            task_id: TaskId::generate(),
            context_id,
            state: TaskState::Completed,
            response_text: String::new(),
            id: MessageId::generate(),
            user_message: None,
            artifacts: Vec::new(),
            metadata: None,
        }
    }

    pub fn with_task_id(mut self, task_id: TaskId) -> Self {
        self.task_id = task_id;
        self
    }

    pub const fn with_state(mut self, state: TaskState) -> Self {
        self.state = state;
        self
    }

    pub fn with_response_text(mut self, text: String) -> Self {
        self.response_text = text;
        self
    }

    pub fn with_message_id(mut self, id: impl Into<MessageId>) -> Self {
        self.id = id.into();
        self
    }

    pub fn with_user_message(mut self, message: Message) -> Self {
        self.user_message = Some(message);
        self
    }

    pub fn with_artifacts(mut self, artifacts: Vec<Artifact>) -> Self {
        self.artifacts = artifacts;
        self
    }

    pub fn with_metadata(mut self, metadata: TaskMetadata) -> Self {
        self.metadata = Some(metadata);
        self
    }

    pub fn build(self) -> Task {
        let agent_message = Message {
            role: MessageRole::Agent,
            parts: vec![Part::Text(TextPart {
                text: self.response_text.clone(),
            })],
            message_id: self.id.clone(),
            task_id: Some(self.task_id.clone()),
            context_id: self.context_id.clone(),
            metadata: None,
            extensions: None,
            reference_task_ids: None,
        };

        let history = if let Some(user_msg) = self.user_message {
            Some(vec![
                user_msg,
                Message {
                    role: MessageRole::Agent,
                    parts: vec![Part::Text(TextPart {
                        text: self.response_text.clone(),
                    })],
                    message_id: MessageId::generate(),
                    task_id: Some(self.task_id.clone()),
                    context_id: self.context_id.clone(),
                    metadata: None,
                    extensions: None,
                    reference_task_ids: None,
                },
            ])
        } else {
            None
        };

        Task {
            id: self.task_id.clone(),
            context_id: self.context_id.clone(),
            status: TaskStatus {
                state: self.state,
                message: Some(agent_message),
                timestamp: Some(chrono::Utc::now()),
            },
            history,
            artifacts: if self.artifacts.is_empty() {
                None
            } else {
                Some(self.artifacts)
            },
            metadata: self.metadata,
            created_at: Some(chrono::Utc::now()),
            last_modified: Some(chrono::Utc::now()),
        }
    }
}