formal-ai 0.281.0

Formal symbolic AI implementation with OpenAI-compatible APIs
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

//! Small text/byte utilities shared by the dreaming planner.

use super::DreamingAction;
use crate::memory::MemoryEvent;

pub(super) fn searchable_text(event: &MemoryEvent) -> String {
    let mut text = String::new();
    push_opt(&mut text, event.kind.as_deref());
    push_opt(&mut text, event.role.as_deref());
    push_opt(&mut text, event.intent.as_deref());
    push_opt(&mut text, event.tool.as_deref());
    push_opt(&mut text, event.inputs.as_deref());
    push_opt(&mut text, event.outputs.as_deref());
    push_opt(&mut text, event.content.as_deref());
    push_opt(&mut text, event.demo_label.as_deref());
    push_opt(&mut text, event.conversation_id.as_deref());
    push_opt(&mut text, event.conversation_title.as_deref());
    for evidence in &event.evidence {
        push_opt(&mut text, Some(evidence));
    }
    text
}

pub(super) fn estimate_event_bytes(event: &MemoryEvent) -> u64 {
    64 + string_bytes(&event.id)
        + option_bytes(event.kind.as_deref())
        + option_bytes(event.role.as_deref())
        + option_bytes(event.intent.as_deref())
        + option_bytes(event.tool.as_deref())
        + option_bytes(event.inputs.as_deref())
        + option_bytes(event.outputs.as_deref())
        + option_bytes(event.content.as_deref())
        + option_bytes(event.sent_at.as_deref())
        + option_bytes(event.demo_label.as_deref())
        + option_bytes(event.conversation_id.as_deref())
        + option_bytes(event.conversation_title.as_deref())
        + event
            .evidence
            .iter()
            .map(|entry| string_bytes(entry))
            .sum::<u64>()
}

pub(super) fn selected_bytes(actions: &[DreamingAction]) -> u64 {
    actions.iter().map(|action| action.estimated_bytes).sum()
}

pub(super) fn required_reclaim_bytes(
    target_free_bytes: Option<u64>,
    free_bytes: Option<u64>,
    incoming_bytes: u64,
) -> u64 {
    let Some(target_free_bytes) = target_free_bytes else {
        return 0;
    };
    let free_after_incoming = free_bytes.unwrap_or(0).saturating_sub(incoming_bytes);
    target_free_bytes.saturating_sub(free_after_incoming)
}

pub(super) fn percent_ceil(total: u64, percent: u8) -> u64 {
    if percent == 0 || total == 0 {
        return 0;
    }
    total.saturating_mul(u64::from(percent)).saturating_add(99) / 100
}

pub(super) fn push_opt(target: &mut String, value: Option<&str>) {
    if let Some(value) = value {
        target.push('\n');
        target.push_str(value);
    }
}

pub(super) fn contains_any(haystack: &str, needles: &[String]) -> bool {
    needles
        .iter()
        .any(|needle| haystack.contains(needle.as_str()))
}

pub(super) fn lower_opt(value: Option<&str>) -> String {
    value.unwrap_or_default().to_ascii_lowercase()
}

pub(super) fn normalized(value: Option<&str>) -> String {
    value.unwrap_or_default().trim().to_ascii_lowercase()
}

pub(super) fn option_bytes(value: Option<&str>) -> u64 {
    value.map_or(0, string_bytes)
}

pub(super) const fn string_bytes(value: &str) -> u64 {
    value.len() as u64
}