runifold-model 0.5.2

Provider-neutral model protocol and streaming primitives for Runifold
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

//! Conservative capability aggregation across physical model routes.

use std::collections::BTreeSet;

use super::ModelCapabilities;

pub(super) fn intersect_capabilities(mut all: Vec<ModelCapabilities>) -> ModelCapabilities {
    let Some(mut intersection) = all.pop() else {
        return ModelCapabilities::default();
    };
    for capabilities in all {
        intersect_feature(&mut intersection.streaming, &capabilities.streaming);
        intersect_feature(&mut intersection.tools, &capabilities.tools);
        intersect_feature(
            &mut intersection.parallel_tools,
            &capabilities.parallel_tools,
        );
        intersect_feature(
            &mut intersection.structured_output,
            &capabilities.structured_output,
        );
        intersect_feature(&mut intersection.reasoning, &capabilities.reasoning);
        intersect_feature(&mut intersection.image_input, &capabilities.image_input);
        intersect_feature(&mut intersection.audio_input, &capabilities.audio_input);
        intersect_feature(
            &mut intersection.document_input,
            &capabilities.document_input,
        );
        intersection.max_context_tokens = match (
            intersection.max_context_tokens,
            capabilities.max_context_tokens,
        ) {
            (Some(left), Some(right)) => Some(left.min(right)),
            _ => None,
        };
        let common = intersection
            .extensions
            .keys()
            .filter(|key| capabilities.extensions.contains_key(*key))
            .cloned()
            .collect::<BTreeSet<_>>();
        intersection.extensions.retain(|key, support| {
            if !common.contains(key) {
                return false;
            }
            if let Some(other) = capabilities.extensions.get(key) {
                intersect_feature(support, other);
            }
            true
        });
    }
    intersection
}

fn intersect_feature(left: &mut crate::FeatureSupport, right: &crate::FeatureSupport) {
    use crate::SupportLevel::{Emulated, Native, Unknown, Unsupported};

    let constraints_match = left.constraints == right.constraints;
    left.level = match (left.level, right.level) {
        (Unsupported, _) | (_, Unsupported) => Unsupported,
        (Unknown, _) | (_, Unknown) => Unknown,
        (Emulated, _) | (_, Emulated) => Emulated,
        (Native, Native) => Native,
    };
    if !constraints_match {
        if left.level != Unsupported {
            left.level = Unknown;
        }
        left.constraints.clear();
    }
}