rlmesh-runtime 0.1.0-rc.8

Internal RLMesh crate (unstable Rust API): runtime driver for evaluation sessions.
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

use crate::spec::{RuntimeLimits, RuntimeSessionSpec};

use super::*;

#[test]
fn route_state_tracks_slot_episode_records() {
    let mut spec = test_session_spec();
    spec.num_envs = 2;
    let mut state = RouteState::new(&spec);

    let started = state.start_episodes(vec!["env-ep-a".to_string(), "env-ep-b".to_string()], false);

    assert_eq!(started.len(), 2);
    assert_eq!(state.snapshot().episode_ids, ["env-ep-a", "env-ep-b"]);
    assert_eq!(
        state.snapshot().episode_record_ids,
        ["ep-000001", "ep-000002"]
    );
    assert_eq!(state.episode_ids(), ["env-ep-a", "env-ep-b"]);
}

#[test]
fn route_state_generates_monotonic_request_ids() {
    let state_spec = test_session_spec();
    let mut state = RouteState::new(&state_spec);

    assert_eq!(state.next_request_id("reset"), "test-env:reset:000001");
    assert_eq!(state.next_request_id("step"), "test-env:step:000002");
}

#[test]
fn request_ids_do_not_collide_across_sibling_envs() {
    let mut spec_a = test_session_spec();
    spec_a.env_id = "env-a".to_string();
    let mut spec_b = test_session_spec();
    spec_b.env_id = "env-b".to_string();
    assert_eq!(spec_a.session_id, spec_b.session_id);

    let mut state_a = RouteState::new(&spec_a);
    let mut state_b = RouteState::new(&spec_b);

    let id_a = state_a.next_request_id("reset");
    let id_b = state_b.next_request_id("reset");

    assert_ne!(
        id_a, id_b,
        "sibling envs in the same session must not share request IDs"
    );
    assert_eq!(id_a, "env-a:reset:000001");
    assert_eq!(id_b, "env-b:reset:000001");
}

#[test]
fn predict_request_includes_seed_metadata_aligned_to_episode_ids() {
    let mut spec = test_session_spec();
    spec.num_envs = 2;
    let mut state = RouteState::new(&spec);
    let episode_ids = vec!["env-ep-a".to_string(), "env-ep-b".to_string()];

    state.start_episodes(episode_ids.clone(), false);
    state.note_episode_seeds(&episode_ids, &[7]);

    let request = state.predict_request(None, RequestPhase::ResetObservation);

    assert_eq!(request.episode_info.len(), 2);
    assert_eq!(request.episode_info[0].episode_id, "env-ep-a");
    assert_eq!(request.episode_info[0].seed, Some(7));
    assert_eq!(request.episode_info[1].episode_id, "env-ep-b");
    assert_eq!(request.episode_info[1].seed, None);
}

#[test]
fn episode_seed_survives_completion_until_the_lane_rolls() {
    let mut state = RouteState::new(&test_session_spec());
    state.start_episodes(vec!["ep-a".to_string()], false);
    state.note_episode_seeds(&["ep-a".to_string()], &[7]);

    // Completion emit reads the seed non-destructively: the same iteration
    // still builds the terminal predict for this episode id.
    state.complete_episode("ep-a");
    let request = state.predict_request(None, RequestPhase::StepObservation);
    assert_eq!(request.episode_info[0].seed, Some(7));

    // The lane rolling to a fresh id is what retires the seed.
    state.observe_episode_ids(vec!["ep-b".to_string()]);
    assert_eq!(state.seed_for_episode("ep-a"), None);
}

fn test_session_spec() -> RuntimeSessionSpec {
    RuntimeSessionSpec {
        session_id: "session".to_string(),
        env_id: "test-env".to_string(),
        env_component_id: "env".to_string(),
        model_component_id: "model".to_string(),
        workflow_edition: rlmesh_proto::CURRENT_WORKFLOW_EDITION.to_string(),
        env_contract: Default::default(),
        num_envs: 1,
        episode_seeds: Vec::new(),
        base_seed: None,
        max_episodes: Some(1),
        max_episode_steps: None,
        max_episode_seconds: None,
        close_env_on_end: true,
        limits: RuntimeLimits::default(),
    }
}