Enum EventHandlerType 

pub enum EventHandlerType {
    Llm {
        instruction: String,
    },
    Script {
        language: String,
        code: String,
        resident: bool,
        scope: Option<String>,
    },
    Static {
        actions: Vec<Value>,
    },
    Manual {
        timeout_secs: u64,
    },
}

Handler type for an event

Variants

Llm

Handle with LLM (default behavior)

Fields

instruction: String

Instruction for how the LLM should handle this event

Script

Handle with inline script

Fields

language: String

Scripting language (python, javascript, go, perl)

code: String

Inline script code

resident: bool

Run the script as a resident process: spawned once per scope and driven with one event per stdin line, keeping in-process state between events. Opt-in; defaults to false (the stateless per-event path). A resident script defines handle(event_type, event, message) instead of reading stdin itself. See src/scripting/resident.rs.

scope: Option<String>

Resident scope: "server" (default — one process shared by all the server’s connections) or "connection" (one process per connection). Ignored unless resident is true.

Static

Handle with static response (actions array)

Action JSON may reference the triggering event with {{event.field}}; see the module docs for the substitution rules.

Fields

actions: Vec<Value>

Actions to execute (actual JSON values, not strings)

Manual

Handled by a human at the dashboard.

The event parks as a pending question (AppState::park_intercept) and the connection waits, exactly as it would for a slow model. Whatever actions the operator composes are executed as the answer; {{event.field}} references work the same as in a static handler. If nobody answers within timeout_secs, the handler fails closed — the dispatch errors and the protocol’s LLM-failure branch answers the peer with a category, never with an invented success.

Fields

timeout_secs: u64

Seconds to wait for the operator before failing closed.

Implementations

impl EventHandlerType

pub fn script(language: impl Into<String>, code: impl Into<String>) -> Self

Create a per-event (stateless) script handler.

pub fn script_resident( language: impl Into<String>, code: impl Into<String>, scope: Option<String>, ) -> Self

Create a resident (persistent) script handler with the given scope ("server" or "connection"; None defaults to server scope).

pub fn static_response(actions: Vec<Value>) -> Self

Create a static handler

pub fn llm(instruction: impl Into<String>) -> Self

Create an LLM handler

pub fn manual(timeout_secs: u64) -> Self

Create a manual (human-answered) handler.

pub fn validate(&self) -> Result<(), InterpolationError>

Validate the handler’s {{event.…}} references without an event.

This is the parse-time half of the check: it catches malformed references ({{event.}}, {{event..x}}, an opening {{event. that is never closed), which are wrong regardless of which event arrives. Whether a well-formed reference resolves depends on the event payload and can only be decided at dispatch time by interpolate_actions.

Callers that parse handler configuration (e.g. EventHandler::parse_event_handlers in src/events/handler.rs) should call this so a typo is reported to the MCP caller at start_server time rather than silently at the first packet.

Trait Implementations

impl Clone for EventHandlerType

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EventHandlerType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventHandlerType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EventHandlerType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.