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

use crate::{agent::AgentEvent, runtime::PersistedAgentRecord};

use super::{Agent, AgentEventTapGuard, AgentStatus};

impl Agent {
    pub(crate) fn emit_event(&self, event: AgentEvent) {
        self.event_bus.send(event);
    }

    pub(crate) fn event_sender(&self) -> super::AgentEventBus {
        self.event_bus.clone()
    }

    pub(crate) fn register_event_tap(
        &self,
        tap: impl Fn(&AgentEvent) + Send + Sync + 'static,
    ) -> AgentEventTapGuard {
        self.event_bus.register_tap(tap)
    }

    pub(crate) fn set_status(&mut self, status: AgentStatus) {
        self.mutate_snapshot(|snapshot| {
            snapshot.status = status;
        });
    }

    pub(super) fn publish_snapshot(&self) {
        let snapshot = self
            .snapshot
            .lock()
            .expect("agent snapshot poisoned")
            .clone();
        self.snapshot_tx.send_replace(snapshot);
    }

    pub(super) fn mutate_snapshot(&self, update: impl FnOnce(&mut crate::agent::AgentSnapshot)) {
        {
            let mut snapshot = self.snapshot.lock().expect("agent snapshot poisoned");
            update(&mut snapshot);
        }
        self.publish_snapshot();
    }

    pub(crate) fn sync_memory_snapshot(&self) {
        let memory_view = self.memory.snapshot_view();
        self.mutate_snapshot(|snapshot| {
            snapshot.history_len = memory_view.history_len;
            snapshot.current_text = memory_view.current_text;
            snapshot.pending_tool_uses = memory_view.pending_tool_uses;
        });
    }

    pub(crate) fn persisted_record(&self) -> PersistedAgentRecord {
        PersistedAgentRecord {
            id: self.id.clone(),
            runtime_identifier: self.runtime.persisted_runtime_identifier().to_string(),
            name: self.name.clone(),
            model: self.model.clone(),
            provider_id: self.provider_id.clone(),
            config: self.config.clone(),
            hidden_tools: self.hidden_tools.clone(),
            max_rounds: self.max_rounds,
            teammate_identity: self.teammate_identity.clone(),
            rounds_since_task: self.rounds_since_task,
            idle_requested: self.idle_requested,
            status: self.watch_snapshot().borrow().status.clone(),
            subagents: self.watch_snapshot().borrow().subagents.clone(),
        }
    }

    pub(crate) fn persist_agent_record(&self) -> Result<(), crate::error::RuntimeError> {
        self.runtime
            .store()
            .save_agent_record(&self.persisted_record())
    }

    pub(crate) fn start_run_checkpoint(&mut self) -> Result<String, crate::runtime::RuntimeError> {
        let run_id = self.runtime.store().start_run(&self.id)?;
        self.current_run_id = Some(run_id.clone());
        Ok(run_id)
    }

    pub(crate) fn update_run_state(
        &self,
        state: &str,
        error: Option<&str>,
    ) -> Result<(), crate::runtime::RuntimeError> {
        if let Some(run_id) = &self.current_run_id {
            self.runtime
                .store()
                .update_run_state(run_id, state, error)?;
        }
        Ok(())
    }

    pub(crate) fn finish_run_checkpoint(&mut self) -> Result<(), crate::runtime::RuntimeError> {
        if let Some(run_id) = self.current_run_id.take() {
            self.runtime.store().finish_run(&run_id)?;
        }
        Ok(())
    }

    pub(crate) fn fail_run_checkpoint(
        &mut self,
        error: &str,
    ) -> Result<(), crate::runtime::RuntimeError> {
        if let Some(run_id) = self.current_run_id.take() {
            self.runtime.store().fail_run(&run_id, error)?;
        }
        Ok(())
    }
}