Struct RoutingPolicy 

pub struct RoutingPolicy {
    pub llm_threshold: f64,
    pub always_route_alerts: bool,
    pub drop_expired: bool,
    /* private fields */
}

Policy for routing messages to LLM vs local processing

Implements the ECO (Energy/Token Optimization) profile logic:

• Alerts with high priority always routed to LLM
• Expired messages dropped
• Event/State messages scored using SFE and routed based on threshold
• Commands/Queries typically processed locally

Examples

use lnmp_core::LnmpRecord;
use lnmp_envelope::EnvelopeBuilder;
use lnmp_net::{MessageKind, NetMessage, RoutingPolicy, RoutingDecision};

let policy = RoutingPolicy::default();

// Alert message -> always to LLM
let envelope = EnvelopeBuilder::new(LnmpRecord::new())
    .timestamp(1000)
    .build();
let alert = NetMessage::new(envelope, MessageKind::Alert);
assert_eq!(policy.decide(&alert, 2000).unwrap(), RoutingDecision::SendToLLM);

Fields

llm_threshold: f64

Minimum importance score (0.0-1.0) to route to LLM

always_route_alerts: bool

Always route Alert messages to LLM regardless of score

drop_expired: bool

Automatically drop expired messages

Implementations

impl RoutingPolicy

pub fn new(llm_threshold: f64) -> Self

Creates a new routing policy with custom threshold

pub fn with_always_route_alerts(self, enabled: bool) -> Self

Sets whether to always route alerts to LLM

pub fn with_drop_expired(self, enabled: bool) -> Self

Sets whether to drop expired messages

pub fn with_scorer_config(self, config: ContextScorerConfig) -> Self

Sets custom SFE scorer configuration

pub fn decide(&self, msg: &NetMessage, now_ms: u64) -> Result<RoutingDecision>

Decides how to route a message

Decision flow:

1. Check expiry (if enabled) -> Drop
2. Check if Alert + high priority -> SendToLLM
3. For Event/State: compute importance score -> threshold check
4. Commands/Queries -> ProcessLocally

Arguments

• msg - The message to route
• now_ms - Current time in epoch milliseconds

pub fn base_importance(&self, msg: &NetMessage, now_ms: u64) -> Result<f64>

Computes base importance score for a message (0.0-1.0)

Combines:

• Priority (0-255 normalized to 0.0-1.0): 50% weight
• SFE score (freshness + importance from lnmp-sfe): 50% weight

Formula

importance = (priority / 255.0) * 0.5 + sfe_score * 0.5

Trait Implementations

impl Clone for RoutingPolicy

fn clone(&self) -> RoutingPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RoutingPolicy

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

Formats the value using the given formatter.

impl Default for RoutingPolicy

fn default() -> Self

Returns the “default value” for a type.