vv-agent 0.4.0

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::collections::{BTreeMap, BTreeSet};
use std::path::PathBuf;

use serde_json::Value;

pub(super) fn read_u64_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: u64,
) -> u64 {
    metadata
        .get(key)
        .and_then(|value| match value {
            Value::Number(number) => number.as_u64(),
            Value::String(text) => text.trim().parse::<u64>().ok(),
            _ => None,
        })
        .unwrap_or(default)
}

pub(super) fn read_usize_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: usize,
) -> usize {
    read_u64_metadata(metadata, key, default as u64) as usize
}

pub(super) fn read_f64_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: f64,
    minimum: f64,
    maximum: Option<f64>,
) -> f64 {
    let mut value = metadata
        .get(key)
        .and_then(parse_f64_metadata_value)
        .unwrap_or(default)
        .max(minimum);
    if let Some(maximum) = maximum {
        value = value.min(maximum);
    }
    value
}

pub(super) fn parse_f64_metadata_value(value: &Value) -> Option<f64> {
    match value {
        Value::Number(number) => number.as_f64(),
        Value::String(text) => text.trim().parse::<f64>().ok(),
        _ => None,
    }
}

pub(super) fn read_bool_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: bool,
) -> bool {
    read_optional_bool_metadata(metadata, key).unwrap_or(default)
}

fn read_optional_bool_metadata(metadata: &BTreeMap<String, Value>, key: &str) -> Option<bool> {
    metadata.get(key).and_then(|value| match value {
        Value::Bool(flag) => Some(*flag),
        Value::Number(number) => match number.as_i64() {
            Some(0) => Some(false),
            Some(1) => Some(true),
            _ => None,
        },
        Value::String(text) => match text.trim().to_ascii_lowercase().as_str() {
            "true" | "1" | "yes" | "y" | "on" => Some(true),
            "false" | "0" | "no" | "n" | "off" => Some(false),
            _ => None,
        },
        _ => None,
    })
}

pub(super) fn session_memory_enabled(metadata: &BTreeMap<String, Value>) -> bool {
    read_optional_bool_metadata(metadata, "session_memory_enabled")
        .or_else(|| read_optional_bool_metadata(metadata, "enable_session_memory"))
        .unwrap_or_else(|| !read_bool_metadata(metadata, "is_sub_task", false))
}

pub(super) fn read_string_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: &str,
) -> String {
    metadata
        .get(key)
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or(default)
        .to_string()
}

pub(super) fn read_optional_string_metadata(
    metadata: &BTreeMap<String, Value>,
    keys: &[&str],
) -> Option<String> {
    keys.iter().find_map(|key| {
        metadata
            .get(*key)
            .and_then(Value::as_str)
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .map(str::to_string)
    })
}

pub(super) fn read_string_set_metadata(
    metadata: &BTreeMap<String, Value>,
    key: &str,
) -> Option<BTreeSet<String>> {
    let values = metadata.get(key)?.as_array()?;
    let values = values
        .iter()
        .filter_map(Value::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(str::to_string)
        .collect::<BTreeSet<_>>();
    (!values.is_empty()).then_some(values)
}

pub(super) fn metadata_path(
    metadata: &BTreeMap<String, Value>,
    key: &str,
    default: &str,
) -> PathBuf {
    metadata
        .get(key)
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from(default))
}