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