theway-core 0.1.21

theway core — stateful agent runtime + harness (Agent loop, skills, prompt templates, sessions, compaction) on top of theway-llm-provider.
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
107
108
109
110
111
112
113
114
115
116

//! Assembly of session entries into the LLM `AgentMessage` list.

use crate::agent::context::collapse::{COMPACT_CONTEXT_CUSTOM_TYPE, compact_context_text};
use crate::agent::messages::{branch_summary, compaction_summary, custom};
use crate::agent::session::session::{SessionContext, SessionContextModel, SessionTreeEntry};
use crate::types::AgentMessage;

/// Replay session entries into the in-memory context used by the agent loop.
pub fn build_session_context(path_entries: &[SessionTreeEntry]) -> SessionContext {
    let mut thinking_level = String::from("off");
    let mut model: Option<SessionContextModel> = None;
    let mut compaction_idx: Option<usize> = None;

    for (i, entry) in path_entries.iter().enumerate() {
        match entry {
            SessionTreeEntry::ThinkingLevelChange {
                thinking_level: t, ..
            } => {
                thinking_level = t.clone();
            }
            SessionTreeEntry::ModelChange {
                provider, model_id, ..
            } => {
                model = Some(SessionContextModel {
                    provider: provider.clone(),
                    model_id: model_id.clone(),
                });
            }
            SessionTreeEntry::Message {
                message: AgentMessage::Llm(theway_llm_provider::Message::Assistant(a)),
                ..
            } => {
                model = Some(SessionContextModel {
                    provider: a.provider.0.clone(),
                    model_id: a.model.clone(),
                });
            }
            SessionTreeEntry::Compaction { .. } => {
                compaction_idx = Some(i);
            }
            _ => {}
        }
    }

    let mut messages: Vec<AgentMessage> = Vec::new();
    let append = |messages: &mut Vec<AgentMessage>, entry: &SessionTreeEntry| match entry {
        SessionTreeEntry::Message { message, .. } => messages.push(message.clone()),
        SessionTreeEntry::CustomMessage {
            custom_type,
            content,
            details,
            timestamp,
            ..
        } => {
            let ts = chrono::DateTime::parse_from_rfc3339(timestamp)
                .map(|d| d.timestamp_millis())
                .unwrap_or_else(|_| chrono::Utc::now().timestamp_millis());
            messages.push(custom(
                custom_type.clone(),
                serde_json::json!({ "content": content, "details": details, "timestamp": ts }),
            ));
        }
        SessionTreeEntry::BranchSummary { summary, .. } if !summary.is_empty() => {
            messages.push(branch_summary(summary.clone()));
        }
        SessionTreeEntry::Custom { custom_type, .. }
            if custom_type == COMPACT_CONTEXT_CUSTOM_TYPE =>
        {
            if let Some(text) = compact_context_text(entry) {
                messages.push(AgentMessage::Custom(crate::types::CustomMessage {
                    role: "collapse_context".into(),
                    timestamp: chrono::Utc::now().timestamp_millis(),
                    payload: serde_json::json!({ "summary": text }),
                }));
            }
        }
        _ => {}
    };

    if let Some(idx) = compaction_idx {
        let SessionTreeEntry::Compaction {
            summary,
            first_kept_entry_id,
            ..
        } = &path_entries[idx]
        else {
            unreachable!()
        };
        messages.push(compaction_summary(summary.clone()));
        let mut found_first_kept = false;
        for (i, entry) in path_entries.iter().enumerate() {
            if i >= idx {
                break;
            }
            if entry.id() == first_kept_entry_id.as_str() {
                found_first_kept = true;
            }
            if found_first_kept {
                append(&mut messages, entry);
            }
        }
        for entry in &path_entries[idx + 1..] {
            append(&mut messages, entry);
        }
    } else {
        for entry in path_entries {
            append(&mut messages, entry);
        }
    }

    SessionContext {
        messages,
        thinking_level,
        model,
    }
}