vtcode-llm 0.175.3

LLM provider abstraction, client implementations, and streaming for VT Code
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

//! Text-only, single-question Decisions choice contract.

use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use vtcode_commons::tool_types::CompactStr;

use super::{LLMError, Usage};

/// The model supported by the experimental Decisions endpoint.
pub const DECISIONS_MODEL: &str = "gpt-6-luna";

/// One supplied text category and its meaning.
#[derive(Debug, Clone, Serialize)]
pub struct DecisionChoiceOption {
    pub value: CompactStr,
    pub description: CompactStr,
}

/// Evidence and instructions for exactly one named choice question.
/// Deliberately omits images, predicates, scores, and generation controls.
#[derive(Clone)]
pub struct ChoiceDecisionRequest {
    pub input: String,
    pub name: CompactStr,
    pub instructions: String,
    pub choices: Vec<DecisionChoiceOption>,
}

impl ChoiceDecisionRequest {
    pub(crate) fn payload(&self) -> Result<Value, LLMError> {
        if self.name.is_empty()
            || self.choices.len() < 2
            || self.choices.iter().enumerate().any(|(index, choice)| {
                choice.value.is_empty() || self.choices[..index].iter().any(|previous| previous.value == choice.value)
            })
        {
            return Err(LLMError::Provider {
                message: "Invalid Decisions choice question".to_owned(),
                metadata: None,
            });
        }
        Ok(json!({
            "model": DECISIONS_MODEL,
            "input": self.input,
            "questions": [{"type": "choice", "name": self.name, "instructions": self.instructions, "choices": self.choices}]
        }))
    }
}

/// A probability for one supplied category.
#[derive(Debug, Clone, Deserialize)]
pub struct DecisionProbability {
    pub value: CompactStr,
    pub probability: f64,
}

/// A validated choice answer. Confidence is retained without a threshold.
#[derive(Debug, Clone, Deserialize)]
pub struct ChoiceDecisionAnswer {
    pub name: CompactStr,
    pub choice: CompactStr,
    pub confidence: f64,
    pub probabilities: Vec<DecisionProbability>,
}

/// An inconclusive answer still retains independently parsed billed usage.
#[derive(Debug, Clone)]
pub struct ChoiceDecisionResponse {
    pub answer: Option<ChoiceDecisionAnswer>,
    pub usage: Option<Usage>,
}

impl ChoiceDecisionResponse {
    pub(crate) fn from_payload(payload: &Value, request: &ChoiceDecisionRequest) -> Self {
        let usage = parse_usage(payload.get("usage"));
        let answer = (|| {
            let answers = payload.get("answers")?.as_array()?;
            if answers.len() != 1 || answers.first()?.get("type")?.as_str()? != "choice" {
                return None;
            }
            let answer: ChoiceDecisionAnswer = serde_json::from_value(answers.first()?.clone()).ok()?;
            let allowed = |value: &str| request.choices.iter().any(|option| option.value == value);
            if answer.name != request.name
                || !allowed(&answer.choice)
                || !unit_interval(answer.confidence)
                || answer.probabilities.len() != request.choices.len()
                || answer.probabilities.iter().enumerate().any(|(index, probability)| {
                    !allowed(&probability.value)
                        || !unit_interval(probability.probability)
                        || answer.probabilities[..index]
                            .iter()
                            .any(|previous| previous.value == probability.value)
                })
            {
                return None;
            }
            Some(answer)
        })();
        Self { answer, usage }
    }
}

fn unit_interval(value: f64) -> bool {
    value.is_finite() && (0.0..=1.0).contains(&value)
}

fn parse_usage(value: Option<&Value>) -> Option<Usage> {
    let value = value?;
    let input = u32::try_from(value.get("input_tokens")?.as_u64()?).ok()?;
    let output = u32::try_from(value.get("output_tokens")?.as_u64()?).ok()?;
    let total = u32::try_from(value.get("total_tokens")?.as_u64()?).ok()?;
    if input.checked_add(output)? != total {
        return None;
    }
    Some(Usage {
        prompt_tokens: input,
        completion_tokens: output,
        total_tokens: total,
        cached_prompt_tokens: None,
        cache_creation_tokens: None,
        cache_read_tokens: None,
        iterations: None,
    })
}

#[cfg(test)]
mod tests;