harn-vm 0.10.137

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

//! One registry for provider cache counter aliases.

const READ_FIELDS: &[&str] = &[
    "/cache_read_input_tokens",
    "/prompt_tokens_details/cached_tokens",
    "/input_tokens_details/cached_tokens",
    "/cached_tokens",
    "/cache_read_tokens",
    "/cached_input_tokens",
    "/cached_prompt_tokens",
    "/prompt_cache_hit_tokens",
    "/cache/read_input_tokens",
    "/cacheReadInputTokens",
    "/cachedContentTokenCount",
    "/total_cached_tokens",
];
const WRITE_FIELDS: &[&str] = &[
    "/cache_write_tokens",
    "/cache_creation_input_tokens",
    "/prompt_tokens_details/cache_write_tokens",
    "/prompt_tokens_details/cache_creation_input_tokens",
    "/input_tokens_details/cache_write_tokens",
    "/input_tokens_details/cache_creation_input_tokens",
    "/cache/write_input_tokens",
    "/cacheWriteInputTokens",
];

pub(crate) fn reported_cache_read_tokens(
    value: &serde_json::Value,
) -> Result<Option<i64>, &'static str> {
    reported_counter(value, READ_FIELDS)
}

pub(crate) fn reported_cache_write_tokens(
    value: &serde_json::Value,
) -> Result<Option<i64>, &'static str> {
    reported_counter(value, WRITE_FIELDS)
}

pub(crate) fn extract_cache_read_tokens(
    value: &serde_json::Value,
) -> Result<i64, crate::value::VmError> {
    reported_cache_read_tokens(value)
        .map(|count| count.unwrap_or(0))
        .map_err(invalid_usage)
}

pub(crate) fn extract_cache_write_tokens(
    value: &serde_json::Value,
) -> Result<i64, crate::value::VmError> {
    reported_cache_write_tokens(value)
        .map(|count| count.unwrap_or(0))
        .map_err(invalid_usage)
}

fn invalid_usage(reason: &'static str) -> crate::value::VmError {
    crate::value::VmError::Runtime(format!("invalid provider cache usage: {reason}"))
}

fn reported_counter(
    value: &serde_json::Value,
    paths: &[&str],
) -> Result<Option<i64>, &'static str> {
    let mut reported = None;
    for path in paths {
        if let Some(value) = value.pointer(path) {
            let count = value.as_i64().ok_or("token counter is not an integer")?;
            if count < 0 {
                return Err("negative token count");
            }
            if reported.is_some_and(|previous| previous != count) {
                return Err("token counter aliases disagree");
            }
            reported = Some(count);
        }
    }
    Ok(reported)
}