mentra 0.6.0

An agent runtime for tool-using LLM applications
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

use serde::{Deserialize, Serialize};

use crate::{Message, agent::PendingToolUseSummary, transcript::AgentTranscript};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AgentMemoryState {
    #[serde(default, deserialize_with = "deserialize_transcript")]
    pub transcript: AgentTranscript,
    pub pending_turn: Option<PendingTurnState>,
    pub resumable_user_message: Option<Message>,
    pub compaction: CompactionState,
    pub revision: u64,
    pub run: Option<RunMemoryState>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PendingTurnState {
    pub current_text: String,
    pub pending_tool_uses: Vec<PendingToolUseSummary>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CompactionState;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RunMemoryState {
    pub run_id: String,
    #[serde(default, deserialize_with = "deserialize_transcript")]
    pub baseline_transcript: AgentTranscript,
    pub assistant_committed: bool,
}

fn deserialize_transcript<'de, D>(deserializer: D) -> Result<AgentTranscript, D::Error>
where
    D: serde::Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(untagged)]
    enum TranscriptRepr {
        Transcript(AgentTranscript),
        Legacy(Vec<Message>),
    }

    Ok(match TranscriptRepr::deserialize(deserializer)? {
        TranscriptRepr::Transcript(transcript) => transcript,
        TranscriptRepr::Legacy(messages) => AgentTranscript::from_messages(messages),
    })
}