episodic 0.1.0

Reusable Observational Memory core models and pure transforms.
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

use super::{
    OmRecord, ReflectionEnqueueDecision, ResolvedObservationConfig, ResolvedReflectionConfig,
    decide_observer_write_action, decide_reflection_enqueue,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProcessInputStepOptions {
    pub is_initial_step: bool,
    pub read_only: bool,
    pub has_buffered_observation_chunks: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProcessInputStepPlan {
    pub should_activate_buffered_before_observer: bool,
    pub should_run_observer: bool,
    pub should_activate_buffered_after_observer: bool,
    pub reflection_decision: Option<ReflectionEnqueueDecision>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProcessOutputResultPlan {
    pub should_save_unsaved_messages: bool,
}

pub fn plan_process_input_step(
    record: &OmRecord,
    observation_config: ResolvedObservationConfig,
    reflection_config: ResolvedReflectionConfig,
    requested_at_rfc3339: &str,
    options: ProcessInputStepOptions,
) -> ProcessInputStepPlan {
    let observer = decide_observer_write_action(record, observation_config);
    let should_activate_buffered_before_observer = !options.read_only
        && options.is_initial_step
        && options.has_buffered_observation_chunks
        && observation_config.buffer_tokens.is_some()
        && observer.threshold_reached;
    let should_run_observer = !options.read_only && observer.should_run_observer;
    let should_activate_buffered_after_observer =
        !options.read_only && observer.should_activate_after_observer;
    let reflection_decision = if options.read_only {
        None
    } else {
        Some(decide_reflection_enqueue(
            record,
            reflection_config,
            requested_at_rfc3339,
        ))
    };
    ProcessInputStepPlan {
        should_activate_buffered_before_observer,
        should_run_observer,
        should_activate_buffered_after_observer,
        reflection_decision,
    }
}

pub fn plan_process_output_result(
    read_only: bool,
    unsaved_message_count: usize,
) -> ProcessOutputResultPlan {
    ProcessOutputResultPlan {
        should_save_unsaved_messages: !read_only && unsaved_message_count > 0,
    }
}

#[cfg(test)]
mod tests;