vent-mcp 0.2.0

STDIO MCP server that lets agents vent to configured channels
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

//! Shared delivery service used by MCP tools and CLI mode.
//!
//! This module owns the request policy that used to be split across adapters:
//! trim input, choose the default channel, reject unknown channels, construct one
//! event, dispatch it, and reduce sink statuses to the terse acknowledgement the
//! caller receives.

use std::sync::Arc;

use crate::config::RuntimeConfig;
use crate::sinks::SinkDispatcher;
use crate::types::{first_delivery_error, ListChannelsOutput, VentEvent, VentOutput};

/// Trimmed vent message and optional channel override for delivery.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VentRequest {
    pub message: String,
    pub channel: Option<String>,
}

/// Validates vent input and dispatches one event through configured channel sinks.
#[derive(Clone)]
pub struct VentService {
    config: Arc<RuntimeConfig>,
    dispatcher: SinkDispatcher,
    project: Arc<String>,
}

impl VentService {
    /// Builds a service from validated runtime config and a project directory label.
    #[must_use]
    pub fn new(config: RuntimeConfig, project: String) -> Self {
        let dispatcher = SinkDispatcher::new(Arc::new(config));
        let config = dispatcher.config();
        Self {
            config,
            dispatcher,
            project: Arc::new(project),
        }
    }

    #[must_use]
    pub(crate) fn config(&self) -> &RuntimeConfig {
        &self.config
    }

    /// Returns configured channels and the default channel name.
    #[must_use]
    pub fn list_channels(&self) -> ListChannelsOutput {
        self.config.channel_list()
    }

    /// Trims input, enforces channel policy, dispatches one event, and reports the first sink failure.
    pub async fn send(&self, request: VentRequest) -> VentOutput {
        let message = request.message.trim();
        if message.is_empty() {
            return failure_output(
                self.config.default_channel().to_string(),
                "message must not be empty".to_string(),
            );
        }

        let channel = request
            .channel
            .as_deref()
            .map(str::trim)
            .filter(|channel| !channel.is_empty())
            .unwrap_or_else(|| self.config.default_channel());

        if !self.config.has_channel(channel) {
            return failure_output(channel.to_string(), format!("unknown channel: {channel}"));
        }

        let event = VentEvent::new(
            channel.to_string(),
            message.to_string(),
            self.project.as_ref().clone(),
        );
        let statuses = self.dispatcher.dispatch(&event).await;
        let ok = statuses.iter().all(|status| status.ok);

        VentOutput {
            ok,
            event_id: event.id.to_string(),
            channel: event.channel,
            error: first_delivery_error(&statuses),
        }
    }
}

fn failure_output(channel: String, message: String) -> VentOutput {
    VentOutput {
        ok: false,
        event_id: String::new(),
        channel,
        error: Some(message),
    }
}