thirdshift 0.14.3

Turn a GitHub issue into a ready-for-review pull request, unattended
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

use crate::harness::interpretation::event::{Event, Usage};
use crate::otlp_jsonl::{AnyValue, KeyValue};
use serde_json::Value;

pub(super) fn attribute(key: &str, value: impl ToString) -> KeyValue {
    KeyValue {
        key: key.into(),
        value: Some(AnyValue::String(value.to_string())),
    }
}

fn usage_attributes(
    attrs: &mut Vec<KeyValue>,
    usage: &Usage,
    cost: Option<f64>,
    input_excludes_cache: bool,
) {
    // Claude/Grok's Messages counters exclude cache reads and writes. The
    // other normalized protocols already report inclusive input totals.
    let input = usage.input.map(|input| {
        if input_excludes_cache {
            input
                .saturating_add(usage.cache_read.unwrap_or(0))
                .saturating_add(usage.cache_write.unwrap_or(0))
        } else {
            input
        }
    });
    for (key, value) in [
        ("gen_ai.usage.input_tokens", input),
        ("gen_ai.usage.output_tokens", usage.output),
        ("thirdshift.usage.cache_read_tokens", usage.cache_read),
        ("thirdshift.usage.cache_write_tokens", usage.cache_write),
    ] {
        if let Some(value) = value {
            attrs.push(KeyValue {
                key: key.into(),
                value: Some(
                    i64::try_from(value)
                        .map(AnyValue::Int)
                        .unwrap_or_else(|_| AnyValue::String(value.to_string())),
                ),
            });
        }
    }
    if let Some(cost) = cost {
        attrs.push(KeyValue {
            key: "thirdshift.cost.usd".into(),
            value: Some(AnyValue::Double(cost)),
        });
    }
}

pub(super) fn event_attributes(event: &Event, input_excludes_cache: bool) -> Vec<KeyValue> {
    use Event::*;
    let mut attrs = Vec::new();
    let json = serde_json::to_value(event).unwrap();
    attrs.push(attribute(
        "thirdshift.event",
        serde_json::to_string(&json).unwrap(),
    ));
    for (key, value) in json.as_object().unwrap() {
        if value.is_null() {
            continue;
        }
        attrs.push(attribute(
            &format!("thirdshift.{key}"),
            match value {
                Value::String(text) => text.clone(),
                _ => value.to_string(),
            },
        ));
    }
    match event {
        ModelCallStarted { model, .. } | ModelCallEnded { model, .. } => {
            attrs.push(attribute("gen_ai.operation.name", "chat"));
            if let Some(model) = model {
                attrs.push(attribute("gen_ai.response.model", model));
            }
        }
        ToolCallStarted {
            tool, id, input, ..
        }
        | ToolCallEnded {
            tool, id, input, ..
        } => {
            attrs.push(attribute("gen_ai.operation.name", "execute_tool"));
            attrs.push(attribute("gen_ai.tool.name", tool));
            attrs.push(attribute("gen_ai.tool.call.id", id));
            attrs.push(attribute("gen_ai.tool.call.arguments", input));
            if let ToolCallEnded { result, .. } = event {
                attrs.push(attribute("gen_ai.tool.call.result", result));
            }
        }
        _ => {}
    }
    match event {
        ModelCallEnded {
            usage, cost_usd, ..
        }
        | Usage {
            usage, cost_usd, ..
        } => usage_attributes(&mut attrs, usage, *cost_usd, input_excludes_cache),
        TurnEnded { usage, .. } => usage_attributes(&mut attrs, usage, None, input_excludes_cache),
        _ => {}
    }
    attrs
}