meerkat-mobkit 0.6.52

Companion orchestration platform for the Meerkat multi-agent runtime
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

//! Parameter parsing for scheduling RPC methods.

use super::*;

pub(super) fn parse_scheduling_params(
    params: &Value,
) -> Result<(Vec<ScheduleDefinition>, u64), String> {
    let object = params
        .as_object()
        .ok_or_else(|| "scheduling params must be a JSON object".to_string())?;
    let tick_ms = object
        .get("tick_ms")
        .and_then(Value::as_u64)
        .ok_or_else(|| "tick_ms must be a u64".to_string())?;
    if tick_ms > i64::MAX as u64 {
        return Err(format!("tick_ms must be <= {}", i64::MAX));
    }
    let schedules = object
        .get("schedules")
        .and_then(Value::as_array)
        .ok_or_else(|| "schedules must be an array".to_string())?;
    if schedules.len() > MAX_SCHEDULES_PER_REQUEST {
        return Err(format!(
            "schedules must contain at most {MAX_SCHEDULES_PER_REQUEST} entries"
        ));
    }

    let mut parsed = Vec::with_capacity(schedules.len());
    for schedule in schedules {
        let entry = schedule
            .as_object()
            .ok_or_else(|| "each schedule must be an object".to_string())?;
        let schedule_id = entry
            .get("schedule_id")
            .and_then(Value::as_str)
            .filter(|value| !value.trim().is_empty())
            .ok_or_else(|| "schedule_id must be a non-empty string".to_string())?;
        let interval = entry
            .get("interval")
            .and_then(Value::as_str)
            .filter(|value| !value.trim().is_empty())
            .ok_or_else(|| "interval must be a non-empty string".to_string())?;
        let timezone = entry
            .get("timezone")
            .and_then(Value::as_str)
            .filter(|value| !value.trim().is_empty())
            .ok_or_else(|| "timezone must be a non-empty string".to_string())?;
        let jitter_ms = entry
            .get("jitter_ms")
            .map(|value| {
                value
                    .as_u64()
                    .ok_or_else(|| "jitter_ms must be a u64".to_string())
            })
            .transpose()?
            .unwrap_or(0);
        let catch_up = entry
            .get("catch_up")
            .map(|value| {
                value
                    .as_bool()
                    .ok_or_else(|| "catch_up must be a boolean".to_string())
            })
            .transpose()?
            .unwrap_or(false);
        let enabled = entry
            .get("enabled")
            .map(|value| {
                value
                    .as_bool()
                    .ok_or_else(|| "enabled must be a boolean".to_string())
            })
            .transpose()?
            .unwrap_or(true);
        parsed.push(ScheduleDefinition {
            schedule_id: schedule_id.trim().to_string(),
            interval: interval.to_string(),
            timezone: timezone.to_string(),
            enabled,
            jitter_ms,
            catch_up,
        });
    }

    validate_schedules(&parsed).map_err(format_schedule_validation_error)?;

    Ok((parsed, tick_ms))
}

pub(super) fn format_schedule_validation_error(err: ScheduleValidationError) -> String {
    match err {
        ScheduleValidationError::EmptyScheduleId => {
            "schedule_id must be a non-empty string".to_string()
        }
        ScheduleValidationError::DuplicateScheduleId(schedule_id) => {
            format!("duplicate schedule_id '{schedule_id}' is not allowed")
        }
        ScheduleValidationError::InvalidTickMs(tick_ms) => {
            format!(
                "tick_ms '{tick_ms}' is unsupported (must be <= {})",
                i64::MAX
            )
        }
        ScheduleValidationError::InvalidInterval {
            schedule_id,
            interval,
        } => format!("invalid interval '{interval}' for schedule_id '{schedule_id}'"),
        ScheduleValidationError::InvalidTimezone {
            schedule_id,
            timezone,
        } => format!("invalid timezone '{timezone}' for schedule_id '{schedule_id}'"),
    }
}