ai-dispatch 10.51.0

Multi-AI CLI team orchestrator
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

// Owned model-catalog records, including CLI-discovered models and pricing overrides.
// Exports resolved catalog queries without adding a second discovery cache.
// Deps: static model catalog, served-only rows (model_catalog_served), serde.

use anyhow::Result;
use serde::Deserialize;

use super::model_catalog_served::{served_only_models, SERVED_PROBE_AGENTS};
use super::{static_models_for_agent, AgentModel, AGENT_MODELS};
use crate::types::AgentKind;

/// Where a catalog row came from. Only `Catalog` rows carry a rating.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ModelOrigin {
    Catalog,
    Served,
    PricingOverride,
}

impl ModelOrigin {
    pub fn label(self) -> &'static str {
        match self {
            Self::Catalog => "catalog",
            Self::Served => "served",
            Self::PricingOverride => "pricing_override",
        }
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct PricingFileModel {
    pub agent: String,
    pub model: String,
    pub input_per_m: f64,
    pub output_per_m: f64,
    pub tier: String,
    pub description: String,
    pub updated: String,
}

#[derive(Debug, Clone)]
pub struct ResolvedAgentModel {
    pub agent: AgentKind,
    pub model: String,
    pub tier: String,
    pub description: String,
    pub capability: Option<f64>,
    pub origin: ModelOrigin,
}

impl From<&AgentModel> for ResolvedAgentModel {
    fn from(model: &AgentModel) -> Self {
        Self {
            agent: model.agent,
            model: model.model.to_string(),
            tier: model.tier.to_string(),
            description: model.description.to_string(),
            capability: Some(model.capability),
            origin: ModelOrigin::Catalog,
        }
    }
}

impl ResolvedAgentModel {
    pub fn from_override(agent: AgentKind, model: PricingFileModel) -> Self {
        let PricingFileModel { model, tier, description, .. } = model;
        Self {
            agent,
            model,
            tier,
            description,
            capability: None,
            origin: ModelOrigin::PricingOverride,
        }
    }
}

pub fn models_for_agent(agent: &AgentKind) -> Vec<ResolvedAgentModel> {
    let mut models: Vec<_> = static_models_for_agent(agent)
        .into_iter()
        .map(ResolvedAgentModel::from)
        .collect();
    models.extend(served_only_models(*agent));
    models
}

#[derive(Debug, Clone, Deserialize)]
pub struct PricingResponse {
    pub models: Vec<PricingFileModel>,
}

pub fn load_pricing_overrides() -> Result<Vec<PricingFileModel>> {
    let path = crate::paths::pricing_path();
    if !path.exists() {
        return Ok(Vec::new());
    }
    let contents = std::fs::read_to_string(path)?;
    let response: PricingResponse = serde_json::from_str(&contents)?;
    Ok(response.models)
}

pub fn merged_agent_models() -> Result<Vec<ResolvedAgentModel>> {
    let mut merged = Vec::with_capacity(AGENT_MODELS.len());
    for model in AGENT_MODELS {
        merged.push(ResolvedAgentModel::from(model));
    }
    for model in SERVED_PROBE_AGENTS.iter().flat_map(|agent| served_only_models(*agent)) {
        merged.push(model);
    }
    for model in load_pricing_overrides()? {
        let Some(agent) = AgentKind::parse_str(&model.agent) else {
            continue;
        };
        if let Some(listed) = merged.iter_mut()
            .find(|row| row.agent == agent && row.model.eq_ignore_ascii_case(&model.model)) {
            listed.tier = model.tier;
            listed.description = model.description;
        } else {
            merged.push(ResolvedAgentModel::from_override(agent, model));
        }
    }
    Ok(merged)
}