episodic 0.2.3

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
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

use crate::addon::reflection_command_from_action;
use crate::config::ResolvedReflectionConfig;
use crate::model::OmRecord;

use super::super::types::{ReflectionAction, ReflectionEnqueueDecision};

pub fn should_trigger_reflector(observation_tokens: u32, threshold: u32) -> bool {
    observation_tokens > threshold
}

pub fn select_reflection_action(
    observation_tokens: u32,
    reflection_threshold: u32,
    buffer_activation: Option<f32>,
    block_after: Option<u32>,
    has_buffered_reflection: bool,
    is_buffering_reflection: bool,
    is_reflecting: bool,
) -> ReflectionAction {
    if is_reflecting {
        return ReflectionAction::None;
    }

    let reflector_threshold_reached =
        should_trigger_reflector(observation_tokens, reflection_threshold);
    match buffer_activation {
        None => {
            if reflector_threshold_reached {
                ReflectionAction::Reflect
            } else {
                ReflectionAction::None
            }
        }
        Some(activation) => {
            if !(activation > 0.0 && activation <= 1.0) {
                return ReflectionAction::None;
            }
            if reflector_threshold_reached {
                if has_buffered_reflection {
                    return ReflectionAction::Reflect;
                }
                if block_after
                    .map(|limit| observation_tokens >= limit)
                    .unwrap_or(false)
                {
                    return ReflectionAction::Reflect;
                }
                if is_buffering_reflection {
                    return ReflectionAction::None;
                }
                return ReflectionAction::Buffer;
            }

            if has_buffered_reflection || is_buffering_reflection {
                return ReflectionAction::None;
            }

            let activation_point =
                (f64::from(reflection_threshold) * f64::from(activation)).max(0.0);
            if f64::from(observation_tokens) >= activation_point {
                ReflectionAction::Buffer
            } else {
                ReflectionAction::None
            }
        }
    }
}

pub fn decide_reflection_enqueue(
    record: &OmRecord,
    reflection_config: ResolvedReflectionConfig,
    requested_at_rfc3339: &str,
) -> ReflectionEnqueueDecision {
    let has_buffered_reflection = record
        .buffered_reflection
        .as_deref()
        .is_some_and(|value| !value.trim().is_empty());
    let action = select_reflection_action(
        record.observation_token_count,
        reflection_config.observation_tokens,
        reflection_config.buffer_activation,
        reflection_config.block_after,
        has_buffered_reflection,
        record.is_buffering_reflection,
        record.is_reflecting,
    );
    let command = reflection_command_from_action(
        action,
        &record.scope_key,
        record.generation_count,
        requested_at_rfc3339,
    );
    let (next_is_reflecting, next_is_buffering_reflection) = match action {
        ReflectionAction::None => (record.is_reflecting, record.is_buffering_reflection),
        ReflectionAction::Buffer => (record.is_reflecting, true),
        ReflectionAction::Reflect => (true, false),
    };
    ReflectionEnqueueDecision {
        action,
        command,
        should_increment_trigger_count: action != ReflectionAction::None,
        next_is_reflecting,
        next_is_buffering_reflection,
    }
}