ldp-protocol 0.2.0

LDP — LLM Delegate Protocol: identity-aware communication for multi-agent LLM systems
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! LDP message types.
//!
//! The LDP message envelope wraps all protocol messages with routing,
//! session context, and provenance metadata.

use crate::types::contract::DelegationContract;
use crate::types::error::LdpError;
use crate::types::payload::PayloadMode;
use crate::types::provenance::Provenance;
use serde::{Deserialize, Serialize};
use serde_json::Value;

/// LDP message envelope — wraps every protocol message.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LdpEnvelope {
    /// Message ID (UUID).
    pub message_id: String,

    /// Session ID this message belongs to.
    pub session_id: String,

    /// Sender delegate ID.
    pub from: String,

    /// Recipient delegate ID.
    pub to: String,

    /// Message body.
    pub body: LdpMessageBody,

    /// Payload mode used for this message.
    pub payload_mode: PayloadMode,

    /// ISO 8601 timestamp.
    pub timestamp: String,

    /// Optional provenance (attached to results).
    pub provenance: Option<Provenance>,

    /// HMAC signature of the message (hex-encoded).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,

    /// Signature algorithm (e.g., "hmac-sha256").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature_algorithm: Option<String>,

    /// Replay-prevention nonce (16-byte hex). Required when signing is enabled.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nonce: Option<String>,
}

/// LDP message body variants.
///
/// Maps to the LDP RFC message types. DCI interaction moves are carried
/// as TASK_SUBMIT payloads (no new message types needed per integration spec).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
pub enum LdpMessageBody {
    /// Initial handshake.
    Hello {
        delegate_id: String,
        supported_modes: Vec<PayloadMode>,
    },

    /// Capability manifest response.
    CapabilityManifest { capabilities: Value },

    /// Propose a session with configuration.
    SessionPropose { config: Value },

    /// Accept a proposed session.
    SessionAccept {
        session_id: String,
        negotiated_mode: PayloadMode,
    },

    /// Reject a proposed session.
    SessionReject {
        reason: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        error: Option<LdpError>,
    },

    /// Submit a task within a session.
    TaskSubmit {
        task_id: String,
        skill: String,
        input: Value,
        #[serde(skip_serializing_if = "Option::is_none")]
        contract: Option<DelegationContract>,
    },

    /// Task progress update.
    TaskUpdate {
        task_id: String,
        progress: Option<f32>,
        message: Option<String>,
    },

    /// Task result.
    TaskResult {
        task_id: String,
        output: Value,
        provenance: Provenance,
    },

    /// Task failure.
    TaskFailed { task_id: String, error: LdpError },

    /// Task cancellation request.
    TaskCancel { task_id: String },

    /// Attestation (trust signal).
    Attestation { claim: Value, evidence: Value },

    /// Session close.
    SessionClose { reason: Option<String> },
}

impl LdpEnvelope {
    /// Create a new envelope with auto-generated message ID and timestamp.
    pub fn new(
        session_id: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
        body: LdpMessageBody,
        payload_mode: PayloadMode,
    ) -> Self {
        Self {
            message_id: uuid::Uuid::new_v4().to_string(),
            session_id: session_id.into(),
            from: from.into(),
            to: to.into(),
            body,
            payload_mode,
            timestamp: chrono::Utc::now().to_rfc3339(),
            provenance: None,
            signature: None,
            signature_algorithm: None,
            nonce: None,
        }
    }
}