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
106

use std::collections::BTreeMap;

use crate::xml::{escape_xml_attribute, escape_xml_text};

use super::super::helpers::normalize_whitespace;
use super::super::types::{BUFFERED_OBSERVATIONS_SEPARATOR, OmObserverMessageCandidate};

pub fn build_other_conversation_blocks(
    candidates: &[OmObserverMessageCandidate],
    current_session_id: Option<&str>,
    max_part_chars: usize,
) -> Option<String> {
    if max_part_chars == 0 {
        return None;
    }

    let normalized_current_session_id = current_session_id
        .map(str::trim)
        .filter(|value| !value.is_empty());

    let mut groups = BTreeMap::<String, Vec<&OmObserverMessageCandidate>>::new();
    for candidate in candidates {
        let Some(source_session_id) = candidate
            .source_session_id
            .as_deref()
            .map(str::trim)
            .filter(|value| !value.is_empty())
        else {
            continue;
        };
        if normalized_current_session_id.is_some_and(|current| current == source_session_id) {
            continue;
        }
        groups
            .entry(source_session_id.to_string())
            .or_default()
            .push(candidate);
    }

    if groups.is_empty() {
        return None;
    }

    let mut blocks = Vec::<String>::new();
    for (source_session_id, mut messages) in groups {
        messages.sort_by(|a, b| {
            a.created_at
                .cmp(&b.created_at)
                .then_with(|| a.id.cmp(&b.id))
        });
        let lines = messages
            .into_iter()
            .filter_map(|message| {
                let role = normalize_whitespace(&message.role);
                let text = normalize_whitespace(&message.text);
                if text.is_empty() {
                    return None;
                }
                let bounded = text.chars().take(max_part_chars).collect::<String>();
                if bounded.is_empty() {
                    return None;
                }
                let escaped_text = escape_xml_text(&bounded);
                Some(if role.is_empty() {
                    escaped_text
                } else {
                    format!("[{}] {escaped_text}", escape_xml_text(&role))
                })
            })
            .collect::<Vec<_>>();
        if lines.is_empty() {
            continue;
        }
        let source_session_id = escape_xml_attribute(&source_session_id);
        blocks.push(format!(
            "<other-conversation id=\"{source_session_id}\">\n{}\n</other-conversation>",
            lines.join("\n")
        ));
    }

    if blocks.is_empty() {
        None
    } else {
        Some(blocks.join("\n\n"))
    }
}

pub fn combine_observations_for_buffering(
    active_observations: &str,
    buffered_observations: &str,
) -> Option<String> {
    let active = active_observations.trim();
    let buffered = buffered_observations.trim();
    if active.is_empty() && buffered.is_empty() {
        return None;
    }
    if active.is_empty() {
        return Some(buffered.to_string());
    }
    if buffered.is_empty() {
        return Some(active.to_string());
    }
    Some(format!(
        "{active}\n\n{BUFFERED_OBSERVATIONS_SEPARATOR}\n\n{buffered}"
    ))
}