Skip to main content

conversation_api/
response.rs

1use crate::{ConversationQueue, ThreadSnapshot, ThreadSummary};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5#[serde(rename_all = "camelCase")]
6pub struct QueueMutationResponse {
7    pub operation_id: String,
8    pub request_id: String,
9    pub queue_version: u64,
10    pub disposition: QueueMutationDisposition,
11}
12
13#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
14#[serde(rename_all = "snake_case")]
15pub enum QueueMutationDisposition {
16    Applied,
17    AlreadyApplied,
18}
19
20#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
21#[serde(rename_all = "camelCase")]
22pub struct RequestStatusResponse {
23    pub request_id: String,
24    pub admission: Option<RequestAdmission>,
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
28#[serde(rename_all = "camelCase")]
29pub struct ThreadSession {
30    pub activity_at_unix_ms: i64,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
34#[serde(tag = "mode", rename_all = "snake_case")]
35pub enum ThreadSync {
36    Unchanged {
37        snapshot_version: u64,
38    },
39    Delta {
40        base_snapshot_version: u64,
41        snapshot_version: u64,
42        events: Vec<crate::SnapshotUpdatedEvent>,
43    },
44    Snapshot {
45        snapshot: ThreadSnapshot,
46    },
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
50#[serde(rename_all = "camelCase")]
51pub struct ThreadLoadResponse {
52    pub thread: ThreadSummary,
53    pub session: ThreadSession,
54    pub sync: ThreadSync,
55    pub queue: ConversationQueue,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
59#[serde(rename_all = "camelCase")]
60pub struct MessageEnqueueResponse {
61    pub request_id: String,
62    pub disposition: MessageEnqueueDisposition,
63    #[serde(default, skip_serializing_if = "Option::is_none")]
64    pub queue_version: Option<u64>,
65    #[serde(default, skip_serializing_if = "Option::is_none")]
66    pub admission: Option<RequestAdmission>,
67}
68
69#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
70#[serde(rename_all = "snake_case")]
71pub enum MessageEnqueueDisposition {
72    Scheduled,
73    Queued,
74    Duplicate,
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
78#[serde(rename_all = "camelCase")]
79pub struct TurnSubmitResponse {
80    pub request_id: String,
81    #[serde(default, skip_serializing_if = "Option::is_none")]
82    pub thread_id: Option<String>,
83    pub disposition: TurnSubmitDisposition,
84    #[serde(default, skip_serializing_if = "Option::is_none")]
85    pub session_disposition: Option<TurnSessionDisposition>,
86    #[serde(default, skip_serializing_if = "Option::is_none")]
87    pub queue_version: Option<u64>,
88    #[serde(default, skip_serializing_if = "Option::is_none")]
89    pub admission: Option<RequestAdmission>,
90}
91
92#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
93#[serde(rename_all = "snake_case")]
94pub enum TurnSubmitDisposition {
95    Scheduled,
96    Queued,
97    Duplicate,
98    BlockedPendingInteraction,
99}
100
101#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
102#[serde(rename_all = "snake_case")]
103pub enum TurnSessionDisposition {
104    Existing,
105    Created,
106    RotatedIdleTimeout,
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
110#[serde(rename_all = "camelCase")]
111pub struct SessionStartResponse {
112    pub operation_id: String,
113    pub thread_id: String,
114    pub disposition: SessionStartDisposition,
115    pub catalog: crate::ThreadCatalog,
116}
117
118#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
119#[serde(rename_all = "snake_case")]
120pub enum SessionStartDisposition {
121    Rotated,
122    AlreadyApplied,
123}
124
125#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
126#[serde(rename_all = "camelCase")]
127pub struct InteractionAnswerResponse {
128    pub request_id: String,
129    pub thread_id: String,
130    pub disposition: InteractionAnswerDisposition,
131}
132
133#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
134#[serde(rename_all = "snake_case")]
135pub enum InteractionAnswerDisposition {
136    Accepted,
137    Duplicate,
138    Unavailable,
139    ExpiredSession,
140}
141
142#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
143#[serde(rename_all = "camelCase")]
144pub struct InteractionSubmitResponse {
145    pub request_id: String,
146    pub disposition: InteractionSubmitDisposition,
147}
148
149#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
150#[serde(rename_all = "snake_case")]
151pub enum InteractionSubmitDisposition {
152    Accepted,
153}
154
155#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
156#[serde(rename_all = "camelCase")]
157pub struct RequestCancelResponse {
158    pub request_id: String,
159    pub phase: RequestCancelPhase,
160    pub outcome: RequestCancelOutcome,
161    #[serde(default, skip_serializing_if = "Option::is_none")]
162    pub queue_version: Option<u64>,
163    #[serde(default, skip_serializing_if = "Option::is_none")]
164    pub admission_version: Option<u64>,
165}
166
167#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
168#[serde(rename_all = "snake_case")]
169pub enum RequestCancelPhase {
170    AdmissionWaiting,
171    Waiting,
172    Running,
173}
174
175#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
176#[serde(rename_all = "snake_case")]
177pub enum RequestCancelOutcome {
178    Cancelled,
179    Cancelling,
180}
181
182#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
183#[serde(rename_all = "camelCase")]
184pub struct RequestAdmission {
185    pub state: RequestAdmissionState,
186    pub admission_version: u64,
187    #[serde(default, skip_serializing_if = "Option::is_none")]
188    pub reason: Option<RequestAdmissionReason>,
189    #[serde(default, skip_serializing_if = "Option::is_none")]
190    pub thread_id: Option<String>,
191    #[serde(default, skip_serializing_if = "Option::is_none")]
192    pub queue_version: Option<u64>,
193}
194
195#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
196#[serde(rename_all = "snake_case")]
197pub enum RequestAdmissionState {
198    WaitingHandoff,
199    Bound,
200    Cancelled,
201    Failed,
202}
203
204#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
205#[serde(rename_all = "snake_case")]
206pub enum RequestAdmissionReason {
207    ModeHandoff,
208    WaitingForPriorTurn,
209    Accepted,
210    Cancelled,
211    HandoffFailed,
212}