Skip to main content

kiss_coding/
model_choice.rs

1//! Which model a new session uses when the caller does not name one.
2
3use crate::Settings;
4use crate::session::manager::SessionManager;
5use anyhow::{Context as _, Result};
6use kiss_ai::{Model, Registry, ThinkingLevel};
7
8/// What the caller asked for: a model pattern, a provider, and whether an
9/// API key was given for this run.
10pub struct ModelRequest<'a> {
11    pub pattern: Option<&'a str>,
12    pub provider: Option<&'a str>,
13    pub api_key_given: bool,
14    /// Import a credential from another installed tool when no stored one
15    /// is usable. The CLI does; a library must not write the user's
16    /// credential file on its own.
17    pub import_external_credentials: bool,
18}
19
20/// The model for a session: the requested pattern, else the settings
21/// default, else the provider's default, else the first catalog model with a
22/// usable credential (importing one from another tool when allowed and
23/// that is the only way). `Ok(None)` when no model is usable; the caller says how to fix it.
24pub fn choose(
25    request: &ModelRequest<'_>,
26    settings: &Settings,
27    registry: &Registry,
28) -> Result<Option<(Model, Option<ThinkingLevel>)>> {
29    // CLI flag > settings default > first model with an available key.
30    if let Some(pattern) = &request.pattern {
31        return registry
32            .resolve(pattern, request.provider)
33            .map(Some)
34            .with_context(|| format!("no model matches pattern '{pattern}'"));
35    }
36    if let (Some(provider), Some(model)) = (&settings.default_provider, &settings.default_model)
37        && let Some(found) = registry.resolve(model, Some(provider))
38    {
39        return Ok(Some(found));
40    }
41    if let Some(provider) = request.provider.or(settings.default_provider.as_deref())
42        && let Some(model) = registry.provider_default(provider)
43    {
44        return Ok(Some((model, None)));
45    }
46    if request.api_key_given {
47        let provider = request.provider.unwrap_or("anthropic");
48        if let Some(model) = registry.provider_default(provider) {
49            return Ok(Some((model, None)));
50        }
51    }
52    if let Some(model) = registry
53        .all()
54        .iter()
55        .find(|model| registry.signed_in(&model.provider))
56    {
57        return Ok(Some((model.clone(), None)));
58    }
59    if !request.import_external_credentials {
60        return Ok(None);
61    }
62    // External discovery can query the macOS Keychain. Run it once only after
63    // the fast local scan finds no usable credential.
64    let external = kiss_ai::auth::external::discover();
65    let mut checked = std::collections::HashSet::new();
66    for model in registry.all() {
67        let credential_provider = registry.credential_provider(&model.provider);
68        if !checked.insert(credential_provider) {
69            continue;
70        }
71        if kiss_ai::auth::external::auto_import_unique_from_sources(credential_provider, &external)
72            .ok()
73            .flatten()
74            .is_some()
75            && registry.signed_in(&model.provider)
76        {
77            return Ok(Some((model.clone(), None)));
78        }
79    }
80    Ok(None)
81}
82
83/// The model and thinking level a session starts with, given the `chosen`
84/// result of [`choose`]. A resumed session keeps the model it last used
85/// unless the request names a model or a provider, and keeps its thinking
86/// level unless `thinking` or the model pattern names one.
87pub fn for_session(
88    request: &ModelRequest<'_>,
89    thinking: Option<ThinkingLevel>,
90    chosen: (Model, Option<ThinkingLevel>),
91    manager: &SessionManager,
92    settings: &Settings,
93    registry: &Registry,
94) -> (Model, ThinkingLevel) {
95    let (model, pattern_thinking) = chosen;
96    let (saved_model, saved_thinking) = manager.session_settings();
97    let model = saved_model
98        .filter(|_| request.pattern.is_none() && request.provider.is_none())
99        .and_then(|(provider, id)| registry.resolve(&id, Some(&provider)))
100        .map_or(model, |(model, _)| model);
101    let thinking = thinking
102        .or(pattern_thinking)
103        .or(saved_thinking)
104        .or_else(|| {
105            settings
106                .default_thinking_level
107                .as_deref()
108                .and_then(ThinkingLevel::parse)
109        })
110        .unwrap_or(ThinkingLevel::Off);
111    let thinking = model.clamp_thinking_level(thinking);
112    (model, thinking)
113}
114
115#[cfg(test)]
116mod tests {
117    use super::*;
118
119    #[test]
120    fn a_resumed_session_keeps_its_model_unless_the_caller_names_one() {
121        let registry = Registry::from_builtin();
122        let settings = Settings::default();
123        let mut manager = SessionManager::in_memory(std::path::Path::new("/"));
124        let saved = registry.provider_default("anthropic").unwrap();
125        manager
126            .append_model_change(&saved.provider, &saved.id)
127            .unwrap();
128        manager
129            .append_thinking_level_change(ThinkingLevel::High)
130            .unwrap();
131        let chosen = registry.provider_default("openai").unwrap();
132        let request = |provider| ModelRequest {
133            pattern: None,
134            provider,
135            api_key_given: true,
136            import_external_credentials: false,
137        };
138
139        let (model, thinking) = for_session(
140            &request(None),
141            None,
142            (chosen.clone(), None),
143            &manager,
144            &settings,
145            &registry,
146        );
147        assert_eq!(
148            (model.provider.as_str(), thinking),
149            ("anthropic", ThinkingLevel::High)
150        );
151
152        let (model, thinking) = for_session(
153            &request(Some("openai")),
154            Some(ThinkingLevel::Low),
155            (chosen, None),
156            &manager,
157            &settings,
158            &registry,
159        );
160        assert_eq!(
161            (model.provider.as_str(), thinking),
162            ("openai", ThinkingLevel::Low)
163        );
164
165        // The saved level is moved to one the named model supports.
166        let plain = registry
167            .all()
168            .iter()
169            .find(|model| !model.reasoning)
170            .unwrap()
171            .clone();
172        let named = ModelRequest {
173            pattern: Some(&plain.id),
174            ..request(None)
175        };
176        let (_, thinking) = for_session(
177            &named,
178            None,
179            (plain.clone(), None),
180            &manager,
181            &settings,
182            &registry,
183        );
184        assert_eq!(thinking, ThinkingLevel::Off);
185    }
186}