mars-agents 0.4.8-rc.2

Agent package manager for .agents/ directories
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

use crate::build::bundle::Routing;
use crate::models::ModelsCache;
use crate::models::availability::{RunnableConfidence, RunnablePathSource, resolve_runnable_path};
use crate::models::probes::opencode_cache;

pub(super) struct RoutingInput<'a> {
    pub(super) model: String,
    pub(super) model_token: String,
    pub(super) harness: String,
    pub(super) provider: Option<&'a str>,
    pub(super) alias_resolution_failed: bool,
    pub(super) alias_exists: bool,
    pub(super) cache: &'a ModelsCache,
}

pub(super) struct RoutingResolution {
    pub(super) routing: Routing,
    pub(super) warnings: Vec<String>,
}

pub(super) fn resolve_routing(input: RoutingInput<'_>) -> RoutingResolution {
    let RoutingInput {
        model,
        model_token,
        harness,
        provider,
        alias_resolution_failed,
        alias_exists,
        cache,
    } = input;

    let mut warnings = Vec::new();

    let provider_for_runnable = if alias_resolution_failed {
        ""
    } else {
        provider.unwrap_or("")
    };
    let cached_probe = if harness.eq_ignore_ascii_case("opencode") {
        opencode_cache::read_cached_probe_result()
    } else {
        None
    };
    let runnable = resolve_runnable_path(
        &model,
        provider_for_runnable,
        &harness,
        cached_probe.as_ref(),
    );

    if matches!(
        runnable.source,
        RunnablePathSource::Synthesized | RunnablePathSource::Passthrough
    ) {
        warnings.push(format!(
            "model '{}' does not have a confirmed runnable path for harness '{}'; using {} path '{}'",
            model,
            harness,
            runnable.source.label(),
            runnable.harness_model_id
        ));
    }
    if runnable.confidence == RunnableConfidence::Unknown {
        warnings.push(format!(
            "harness-model for '{}' targeting '{}' is unconfirmed ({})",
            model,
            harness,
            runnable.source.label()
        ));
    }
    if !alias_exists
        && model_token == model
        && !model_exists_in_cache(cache, &model)
        && matches!(runnable.source, RunnablePathSource::Passthrough)
    {
        warnings.push(format!(
            "model '{}' not found in models cache; passing through as harness model ID",
            model_token
        ));
    }

    RoutingResolution {
        routing: Routing {
            model,
            model_token,
            harness,
            harness_model: runnable.harness_model_id,
            harness_model_source: runnable.source.label().to_string(),
            harness_model_confidence: runnable.confidence.label().to_string(),
        },
        warnings,
    }
}

fn model_exists_in_cache(cache: &ModelsCache, model_id: &str) -> bool {
    cache
        .models
        .iter()
        .any(|model| model.id.eq_ignore_ascii_case(model_id))
}