nexo-tool-meta 0.1.2

Wire-shape types shared between the Nexo agent runtime and any third-party microapp that consumes its events.
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

//! Phase 82.10.f — `nexo/admin/channels/*` wire types (Phase 80.9
//! MCP-channel servers in `agents.yaml.<id>.channels.approved`).
//!
//! Distinct from `credentials/*` (Phase 17 native-channel
//! credentials). Channels here are MCP server adapters
//! (slack / telegram-bridge / iMessage relay) the operator
//! pre-approves per agent.

use serde::{Deserialize, Serialize};

/// Filter for `channels/list`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(default)]
pub struct ChannelsListFilter {
    /// Restrict to a single agent.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// One MCP-channel approval row.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ChannelEntry {
    /// Agent id this channel is approved for.
    pub agent_id: String,
    /// MCP server name as advertised at runtime
    /// (e.g. `plugin:telegram:tg`, `slack`).
    pub server_name: String,
    /// Optional binding indices restricting which agent bindings
    /// can use this channel. `None` = all bindings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowlist: Option<Vec<usize>>,
}

/// Response for `channels/list`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ChannelsListResponse {
    /// Matching entries in stable order
    /// (alpha agent_id, then server_name).
    pub entries: Vec<ChannelEntry>,
}

/// Params for `channels/approve`.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ChannelsApproveInput {
    /// Agent id.
    pub agent_id: String,
    /// MCP server name.
    pub server_name: String,
    /// Optional binding allowlist. `None` = all bindings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowlist: Option<Vec<usize>>,
}

/// Params for `channels/revoke`.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ChannelsRevokeParams {
    /// Agent id.
    pub agent_id: String,
    /// MCP server name to remove.
    pub server_name: String,
}

/// Response for `channels/revoke`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ChannelsRevokeResponse {
    /// `true` when the yaml entry was removed.
    pub removed: bool,
}

/// Params for `channels/doctor`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(default)]
pub struct ChannelsDoctorParams {
    /// Optional agent id to scope the report.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    /// Optional binding index to scope further.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub binding_index: Option<usize>,
}

/// One verdict in the doctor report.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ChannelDoctorVerdict {
    /// Agent id.
    pub agent_id: String,
    /// MCP server name being verified.
    pub server_name: String,
    /// `"ok"` | `"warning"` | `"error"`.
    pub status: String,
    /// Operator-readable message.
    pub message: String,
}

/// Response for `channels/doctor`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ChannelDoctorReport {
    /// One verdict per (agent, server_name) pair examined.
    pub verdicts: Vec<ChannelDoctorVerdict>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn channel_entry_round_trip() {
        let e = ChannelEntry {
            agent_id: "ana".into(),
            server_name: "plugin:telegram:tg".into(),
            allowlist: Some(vec![0, 1]),
        };
        let v = serde_json::to_value(&e).unwrap();
        let back: ChannelEntry = serde_json::from_value(v).unwrap();
        assert_eq!(e, back);
    }

    #[test]
    fn channel_entry_skips_none_allowlist() {
        let e = ChannelEntry {
            agent_id: "ana".into(),
            server_name: "slack".into(),
            allowlist: None,
        };
        let v = serde_json::to_value(&e).unwrap();
        let obj = v.as_object().unwrap();
        assert!(!obj.contains_key("allowlist"));
    }
}