lash-remote-protocol 0.1.0-alpha.110

Versioned remote embedding protocol DTOs for Lash sessions, turns, activities, tools, and LLM calls.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

impl From<lash_core::TurnCancellationEvidence> for RemoteTurnCancellationEvidence {
    fn from(value: lash_core::TurnCancellationEvidence) -> Self {
        let lash_core::TurnCancellationEvidence {
            request_id,
            origin,
            reason,
        } = value;
        Self {
            request_id,
            origin,
            reason,
        }
    }
}

impl From<RemoteTurnCancellationEvidence> for lash_core::TurnCancellationEvidence {
    fn from(value: RemoteTurnCancellationEvidence) -> Self {
        let RemoteTurnCancellationEvidence {
            request_id,
            origin,
            reason,
        } = value;
        Self {
            request_id,
            origin,
            reason,
        }
    }
}

impl TryFrom<RemoteTurnCancelRequest> for lash_core::TurnCancelRequest {
    type Error = RemoteProtocolError;

    fn try_from(value: RemoteTurnCancelRequest) -> Result<Self, Self::Error> {
        value.validate()?;
        let RemoteTurnCancelRequest {
            protocol_version: _,
            session_id,
            turn_id,
            request_id,
            origin,
            reason,
        } = value;
        Ok(Self {
            address: lash_core::TurnAddress::new(session_id, turn_id),
            request_id,
            origin,
            reason,
        })
    }
}

impl From<lash_core::TurnCancelRequest> for RemoteTurnCancelRequest {
    fn from(value: lash_core::TurnCancelRequest) -> Self {
        let lash_core::TurnCancelRequest {
            address,
            request_id,
            origin,
            reason,
        } = value;
        Self {
            protocol_version: REMOTE_PROTOCOL_VERSION,
            session_id: address.session_id,
            turn_id: address.turn_id,
            request_id,
            origin,
            reason,
        }
    }
}

impl From<lash_core::TurnCancelOutcome> for RemoteTurnCancelOutcome {
    fn from(value: lash_core::TurnCancelOutcome) -> Self {
        match value {
            lash_core::TurnCancelOutcome::Requested(cancellation) => Self::Requested {
                cancellation: cancellation.into(),
            },
            lash_core::TurnCancelOutcome::AlreadyRequested(cancellation) => {
                Self::AlreadyRequested {
                    cancellation: cancellation.into(),
                }
            }
            lash_core::TurnCancelOutcome::CompletionWonRace => Self::CompletionWonRace,
            lash_core::TurnCancelOutcome::UnknownOrRevoked => Self::UnknownOrRevoked,
        }
    }
}

impl From<RemoteTurnCancelOutcome> for lash_core::TurnCancelOutcome {
    fn from(value: RemoteTurnCancelOutcome) -> Self {
        match value {
            RemoteTurnCancelOutcome::Requested { cancellation } => {
                Self::Requested(cancellation.into())
            }
            RemoteTurnCancelOutcome::AlreadyRequested { cancellation } => {
                Self::AlreadyRequested(cancellation.into())
            }
            RemoteTurnCancelOutcome::CompletionWonRace => Self::CompletionWonRace,
            RemoteTurnCancelOutcome::UnknownOrRevoked => Self::UnknownOrRevoked,
        }
    }
}

impl From<lash_core::DurabilityTier> for RemoteTurnControlDurabilityTier {
    fn from(value: lash_core::DurabilityTier) -> Self {
        match value {
            lash_core::DurabilityTier::Inline => Self::Inline,
            lash_core::DurabilityTier::Durable => Self::Durable,
        }
    }
}

impl From<RemoteTurnControlDurabilityTier> for lash_core::DurabilityTier {
    fn from(value: RemoteTurnControlDurabilityTier) -> Self {
        match value {
            RemoteTurnControlDurabilityTier::Inline => Self::Inline,
            RemoteTurnControlDurabilityTier::Durable => Self::Durable,
        }
    }
}