Skip to main content

muse_code_sdk/msp/view/state/
session_name.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use crate::msp::view::SourceRange;
4use serde::Deserialize;
5use serde::Deserializer;
6use serde::Serialize;
7use serde::Serializer;
8
9/// How the served session name was set. **Open enum** (`x-msp-openness: open`):
10/// v1 serves `automatic` and `custom`; a client MUST read absent — and any
11/// value it does not recognize — as unknown, never fabricated. Open: a future
12/// source such as conversation-generated names adds a value here, so closed
13/// would make that a breaking change.
14#[derive(Debug, Clone, PartialEq, Eq)]
15#[non_exhaustive]
16pub enum SessionNameOrigin {
17    /// The settled name carries no rename proof (an allocate, or a rename
18    /// that never proved: rejected, failed, or superseded).
19    Automatic,
20    /// The settled name carries rename proof (an accepted `Rename` intake
21    /// whose bound task completed, or a validated legacy `source: User`
22    /// chain).
23    Custom,
24    /// A value introduced by a newer host. Preserved so an older client
25    /// reads it as unknown without failing the decode. Not a v1
26    /// server-emission value, so it is excluded from the generated
27    /// known-value schema while the enum remains declared open.
28    Unknown(String),
29}
30
31impl SessionNameOrigin {
32    /// The exact wire spelling, including a future value an older client does
33    /// not understand.
34    #[must_use]
35    pub fn as_str(&self) -> &str {
36        match self {
37            Self::Automatic => "automatic",
38            Self::Custom => "custom",
39            Self::Unknown(value) => value,
40        }
41    }
42}
43
44impl Serialize for SessionNameOrigin {
45    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
46    where
47        S: Serializer,
48    {
49        serializer.serialize_str(self.as_str())
50    }
51}
52
53impl<'de> Deserialize<'de> for SessionNameOrigin {
54    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
55    where
56        D: Deserializer<'de>,
57    {
58        let value = String::deserialize(deserializer)?;
59        Ok(match value.as_str() {
60            "automatic" => Self::Automatic,
61            "custom" => Self::Custom,
62            _ => Self::Unknown(value),
63        })
64    }
65}
66
67/// `session/nameChanged` params: the fold of ANY durable session-name record —
68/// the FIRST-NAMING automatic allocate as well as an accepted `session/rename`
69/// (or the same in-process runtime command). Replace-wholesale like every
70/// sibling.
71#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
72#[serde(rename_all = "camelCase")]
73#[non_exhaustive]
74pub struct SessionNameChangedParams {
75    /// The owning session.
76    pub session_id: String,
77    /// Opaque, strictly monotonic view cursor.
78    pub view_cursor: String,
79    /// The durable records this event folded from.
80    pub source_range: SourceRange,
81    /// The new canonical name now in effect.
82    pub name: String,
83    /// How the new name was set. **Additive-optional**: omitted when the
84    /// emitting fold cannot prove an origin — absent reads as unknown, never
85    /// fabricated.
86    #[serde(skip_serializing_if = "Option::is_none")]
87    pub name_origin: Option<SessionNameOrigin>,
88    /// The latest retained generated short title. **Additive-optional**:
89    /// carried at generated-pair publication and at settlement when a pair is
90    /// already published; omitted when no pair was ever published — absent
91    /// reads as unpublished, never fabricated. `name` stays canonical.
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub generated_name: Option<String>,
94}