harn-vm 0.10.129

Async bytecode virtual machine for the Harn programming language
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

use crate::value::{VmError, VmValue};

use super::{compact_usize_opt, err};

const COMPACT_OPT_KEYS: &[&str] = &[
    "keep_last",
    "token_threshold",
    "tool_output_max_chars",
    "compact_strategy",
    "hard_limit_tokens",
    "hard_limit_strategy",
    "custom_compactor",
    "mask_callback",
    "compress_callback",
    "policy",
    "compaction_policy",
    "compaction_request",
    "instructions",
    "mode",
    "scope",
    "preserve",
    "drop",
    "extend_default_instructions",
    "author",
];

pub(super) fn build_compact_config(
    opts: &crate::value::DictMap,
) -> Result<crate::orchestration::AutoCompactConfig, VmError> {
    for key in opts.keys() {
        if !COMPACT_OPT_KEYS.contains(&key.as_str()) {
            let expected = COMPACT_OPT_KEYS.join(", ");
            return Err(err(format!(
                "agent_session_compact: unknown option key '{key}' (expected one of: {expected})"
            )));
        }
    }

    let mut config = crate::orchestration::AutoCompactConfig {
        policy: crate::orchestration::parse_compaction_policy_options(
            Some(opts),
            "agent_session_compact",
        )?,
        ..Default::default()
    };
    if let Some(value) = compact_usize_opt(opts, "keep_last")? {
        config.keep_last = value;
    }
    if let Some(value) = compact_usize_opt(opts, "token_threshold")? {
        config.token_threshold = value;
    }
    if let Some(value) = compact_usize_opt(opts, "tool_output_max_chars")? {
        config.tool_output_max_chars = value;
    }
    if let Some(VmValue::String(strategy)) = opts.get("compact_strategy") {
        config.compact_strategy = crate::orchestration::parse_compact_strategy(strategy)?;
        config.policy_strategy =
            crate::orchestration::compact_strategy_name(&config.compact_strategy).to_string();
    }
    if let Some(value) = compact_usize_opt(opts, "hard_limit_tokens")? {
        config.hard_limit_tokens = Some(value);
    }
    if let Some(VmValue::String(strategy)) = opts.get("hard_limit_strategy") {
        config.hard_limit_strategy = crate::orchestration::parse_compact_strategy(strategy)?;
    }
    config.custom_compactor = closure_option(opts, "custom_compactor")?;
    config.mask_callback = closure_option(opts, "mask_callback")?;
    config.compress_callback = closure_option(opts, "compress_callback")?;
    config.request_provenance = crate::orchestration::CompactionRequestProvenance {
        requested_strategy: Some(
            crate::orchestration::compact_strategy_name(&config.compact_strategy).to_string(),
        ),
        threshold_source: opts
            .contains_key("token_threshold")
            .then_some(crate::orchestration::CompactionThresholdSource::TokenThreshold),
    };
    Ok(config)
}

fn closure_option(opts: &crate::value::DictMap, key: &str) -> Result<Option<VmValue>, VmError> {
    let Some(value) = opts.get(key).cloned() else {
        return Ok(None);
    };
    if !matches!(value, VmValue::Closure(_)) {
        return Err(err(format!(
            "agent_session_compact: `{key}` must be a closure"
        )));
    }
    Ok(Some(value))
}