1use chrono::{DateTime, Utc};
6use serde::{Deserialize, Serialize};
7use stakpak_shared::models::integrations::openai::ChatMessage;
8use uuid::Uuid;
9
10#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
16#[serde(rename_all = "UPPERCASE")]
17pub enum SessionVisibility {
18 #[default]
19 Private,
20 Public,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
25#[serde(rename_all = "UPPERCASE")]
26pub enum SessionStatus {
27 #[default]
28 Active,
29 Deleted,
30}
31
32#[derive(Debug, Clone, Deserialize)]
34pub struct Session {
35 pub id: Uuid,
36 pub title: String,
37 pub visibility: SessionVisibility,
38 pub status: SessionStatus,
39 pub cwd: Option<String>,
40 pub created_at: DateTime<Utc>,
41 pub updated_at: DateTime<Utc>,
42 pub deleted_at: Option<DateTime<Utc>>,
43 pub active_checkpoint: Option<Checkpoint>,
44}
45
46#[derive(Debug, Clone, Deserialize)]
48pub struct SessionSummary {
49 pub id: Uuid,
50 pub title: String,
51 pub visibility: SessionVisibility,
52 pub status: SessionStatus,
53 pub cwd: Option<String>,
54 pub created_at: DateTime<Utc>,
55 pub updated_at: DateTime<Utc>,
56 pub message_count: u32,
57 pub active_checkpoint_id: Uuid,
58 pub last_message_at: Option<DateTime<Utc>>,
59}
60
61#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct Checkpoint {
68 pub id: Uuid,
69 pub session_id: Uuid,
70 pub parent_id: Option<Uuid>,
71 pub state: CheckpointState,
72 pub created_at: DateTime<Utc>,
73 pub updated_at: DateTime<Utc>,
74}
75
76#[derive(Debug, Clone, Deserialize)]
78pub struct CheckpointSummary {
79 pub id: Uuid,
80 pub session_id: Uuid,
81 pub parent_id: Option<Uuid>,
82 pub message_count: u32,
83 pub created_at: DateTime<Utc>,
84 pub updated_at: DateTime<Utc>,
85 pub state: Option<CheckpointState>,
87}
88
89#[derive(Debug, Clone, Default, Serialize, Deserialize)]
91pub struct CheckpointState {
92 #[serde(default)]
93 pub messages: Vec<ChatMessage>,
94 #[serde(default, skip_serializing_if = "Option::is_none")]
96 pub metadata: Option<serde_json::Value>,
97}
98
99#[derive(Debug, Serialize)]
105pub struct CreateSessionRequest {
106 pub title: String,
108 #[serde(skip_serializing_if = "Option::is_none")]
110 pub visibility: Option<SessionVisibility>,
111 #[serde(skip_serializing_if = "Option::is_none")]
113 pub cwd: Option<String>,
114 pub state: CheckpointState,
116}
117
118#[derive(Debug, Serialize)]
120pub struct CreateCheckpointRequest {
121 pub state: CheckpointState,
123 #[serde(skip_serializing_if = "Option::is_none")]
125 pub parent_id: Option<Uuid>,
126}
127
128#[derive(Debug, Default, Serialize)]
130pub struct ListSessionsQuery {
131 #[serde(skip_serializing_if = "Option::is_none")]
132 pub limit: Option<u32>,
133 #[serde(skip_serializing_if = "Option::is_none")]
134 pub offset: Option<u32>,
135 #[serde(skip_serializing_if = "Option::is_none")]
136 pub search: Option<String>,
137 #[serde(skip_serializing_if = "Option::is_none")]
138 pub status: Option<String>,
139 #[serde(skip_serializing_if = "Option::is_none")]
140 pub visibility: Option<String>,
141}
142
143#[derive(Debug, Serialize)]
145pub struct UpdateSessionRequest {
146 #[serde(skip_serializing_if = "Option::is_none")]
147 pub title: Option<String>,
148 #[serde(skip_serializing_if = "Option::is_none")]
149 pub visibility: Option<SessionVisibility>,
150}
151
152#[derive(Debug, Default, Serialize)]
154pub struct ListCheckpointsQuery {
155 #[serde(skip_serializing_if = "Option::is_none")]
156 pub limit: Option<u32>,
157 #[serde(skip_serializing_if = "Option::is_none")]
158 pub offset: Option<u32>,
159 #[serde(skip_serializing_if = "Option::is_none")]
160 pub include_state: Option<bool>,
161}
162
163#[derive(Debug, Deserialize)]
169pub struct CreateSessionResponse {
170 pub session_id: Uuid,
171 pub checkpoint: Checkpoint,
172}
173
174#[derive(Debug, Deserialize)]
176pub struct CreateCheckpointResponse {
177 pub checkpoint: Checkpoint,
178}
179
180#[derive(Debug, Deserialize)]
182pub struct ListSessionsResponse {
183 pub sessions: Vec<SessionSummary>,
184}
185
186#[derive(Debug, Deserialize)]
188pub struct GetSessionResponse {
189 pub session: Session,
190}
191
192#[derive(Debug, Deserialize)]
194pub struct UpdateSessionResponse {
195 pub session: Session,
196}
197
198#[derive(Debug, Deserialize)]
200pub struct DeleteSessionResponse {
201 pub success: bool,
202 pub deleted_at: DateTime<Utc>,
203}
204
205#[derive(Debug, Deserialize)]
207pub struct ListCheckpointsResponse {
208 pub checkpoints: Vec<CheckpointSummary>,
209}
210
211#[derive(Debug, Deserialize)]
213pub struct GetCheckpointResponse {
214 pub checkpoint: Checkpoint,
215}
216
217#[derive(Debug, Serialize)]
223pub struct SearchDocsRequest {
224 pub keywords: String,
225 #[serde(skip_serializing_if = "Option::is_none")]
226 pub exclude_keywords: Option<String>,
227 #[serde(skip_serializing_if = "Option::is_none")]
228 pub limit: Option<u32>,
229}
230
231#[derive(Debug, Serialize)]
233pub struct SearchMemoryRequest {
234 pub keywords: Vec<String>,
235 #[serde(skip_serializing_if = "Option::is_none")]
236 pub start_time: Option<DateTime<Utc>>,
237 #[serde(skip_serializing_if = "Option::is_none")]
238 pub end_time: Option<DateTime<Utc>>,
239}
240
241#[derive(Debug, Serialize)]
243pub struct SlackReadMessagesRequest {
244 pub channel: String,
245 #[serde(skip_serializing_if = "Option::is_none")]
246 pub limit: Option<u32>,
247}
248
249#[derive(Debug, Serialize)]
251pub struct SlackReadRepliesRequest {
252 pub channel: String,
253 pub ts: String,
254}
255
256#[derive(Debug, Serialize)]
258pub struct SlackSendMessageRequest {
259 pub channel: String,
260 pub markdown_text: String,
261 #[serde(skip_serializing_if = "Option::is_none")]
262 pub thread_ts: Option<String>,
263}
264
265#[derive(Debug, Serialize)]
271pub(crate) struct ToolsCallParams {
272 pub name: String,
273 pub arguments: serde_json::Value,
274}