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

use super::{
    TaskAccess, TaskError,
    input::TaskUpdateInput,
    types::{TaskItem, TaskStatus},
};

pub(super) fn validate_unblocked_status(task: &TaskItem) -> Result<(), TaskError> {
    if matches!(task.status, TaskStatus::InProgress | TaskStatus::Completed)
        && !task.blocked_by.is_empty()
    {
        return Err(TaskError::Validation(format!(
            "Task {} cannot be {} while blocked by {:?}",
            task.id, task.status, task.blocked_by
        )));
    }

    Ok(())
}

pub(super) fn validate_claimable(task: &TaskItem, owner: &str) -> Result<(), TaskError> {
    if !task.owner.is_empty() {
        return Err(TaskError::Validation(format!(
            "Task {} is already owned by '{}'",
            task.id, task.owner
        )));
    }
    if !task.blocked_by.is_empty() {
        return Err(TaskError::Validation(format!(
            "Task {} is blocked by {:?} and cannot be claimed",
            task.id, task.blocked_by
        )));
    }
    if task.status != TaskStatus::Pending {
        return Err(TaskError::Validation(format!(
            "Task {} is {} and cannot be claimed by '{}'",
            task.id, task.status, owner
        )));
    }

    Ok(())
}

pub(super) fn validate_update_access(
    task: &TaskItem,
    input: &TaskUpdateInput,
    access: TaskAccess<'_>,
) -> Result<(), TaskError> {
    match access {
        TaskAccess::Lead => Ok(()),
        TaskAccess::Teammate(name) if task.owner == name => {
            if updates_dependencies(input) {
                return Err(TaskError::Validation(format!(
                    "Teammate '{name}' cannot edit dependencies for task {}",
                    task.id
                )));
            }
            if let Some(owner) = &input.owner
                && owner != name
            {
                return Err(TaskError::Validation(format!(
                    "Teammate '{name}' cannot reassign task {} to '{}'",
                    task.id, owner
                )));
            }
            Ok(())
        }
        TaskAccess::Teammate(name) => Err(TaskError::Validation(format!(
            "Teammate '{name}' cannot update task {} owned by '{}'",
            task.id, task.owner
        ))),
    }
}

pub(super) fn is_claimable(task: &TaskItem) -> bool {
    task.status == TaskStatus::Pending && task.blocked_by.is_empty() && task.owner.is_empty()
}

pub(super) fn find_task_mut(
    tasks: &mut [TaskItem],
    task_id: u64,
) -> Result<&mut TaskItem, TaskError> {
    tasks
        .iter_mut()
        .find(|task| task.id == task_id)
        .ok_or_else(|| TaskError::Validation(format!("Task {task_id} does not exist")))
}

fn updates_dependencies(input: &TaskUpdateInput) -> bool {
    !input.add_blocked_by.is_empty()
        || !input.remove_blocked_by.is_empty()
        || !input.add_blocks.is_empty()
        || !input.remove_blocks.is_empty()
}