mhome-conversation-api 3.0.0

use crate::{ConversationQueue, LiveSnapshot, ThreadSnapshot, ThreadSummary};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct ThreadSession {
    pub activity_at_unix_ms: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "mode", rename_all = "snake_case")]
pub enum ThreadSync {
    Unchanged {
        snapshot_version: u64,
    },
    Delta {
        base_snapshot_version: u64,
        snapshot_version: u64,
        events: Vec<crate::SnapshotUpdatedEvent>,
    },
    Snapshot {
        snapshot: ThreadSnapshot,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ThreadLoadResponse {
    pub thread: ThreadSummary,
    pub session: ThreadSession,
    pub sync: ThreadSync,
    pub live: LiveSnapshot,
    pub queue: ConversationQueue,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct MessageEnqueueResponse {
    pub request_id: String,
    pub disposition: MessageEnqueueDisposition,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_version: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub admission: Option<RequestAdmission>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum MessageEnqueueDisposition {
    Queued,
    Duplicate,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct TurnSubmitResponse {
    pub request_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    pub disposition: TurnSubmitDisposition,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_disposition: Option<TurnSessionDisposition>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_version: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub admission: Option<RequestAdmission>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum TurnSubmitDisposition {
    Queued,
    Duplicate,
    BlockedPendingInteraction,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum TurnSessionDisposition {
    Existing,
    Created,
    RotatedIdleTimeout,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SessionStartResponse {
    pub operation_id: String,
    pub thread_id: String,
    pub disposition: SessionStartDisposition,
    pub catalog: crate::ThreadCatalog,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum SessionStartDisposition {
    Rotated,
    AlreadyApplied,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InteractionAnswerResponse {
    pub request_id: String,
    pub thread_id: String,
    pub disposition: InteractionAnswerDisposition,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum InteractionAnswerDisposition {
    Accepted,
    Duplicate,
    Unavailable,
    ExpiredSession,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InteractionSubmitResponse {
    pub request_id: String,
    pub disposition: InteractionSubmitDisposition,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum InteractionSubmitDisposition {
    Accepted,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RequestCancelResponse {
    pub request_id: String,
    pub phase: RequestCancelPhase,
    pub outcome: RequestCancelOutcome,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_version: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub admission_version: Option<u64>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RequestCancelPhase {
    AdmissionWaiting,
    Waiting,
    Running,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RequestCancelOutcome {
    Cancelled,
    Cancelling,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RequestAdmission {
    pub state: RequestAdmissionState,
    pub admission_version: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<RequestAdmissionReason>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_version: Option<u64>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RequestAdmissionState {
    WaitingHandoff,
    Bound,
    Cancelled,
    Failed,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RequestAdmissionReason {
    ModeHandoff,
    WaitingForPriorTurn,
    Accepted,
    Cancelled,
    HandoffFailed,
}