kiss_coding/
model_choice.rs1use crate::Settings;
4use crate::session::manager::SessionManager;
5use anyhow::{Context as _, Result};
6use kiss_ai::{Model, Registry, ThinkingLevel};
7
8pub struct ModelRequest<'a> {
11 pub pattern: Option<&'a str>,
12 pub provider: Option<&'a str>,
13 pub api_key_given: bool,
14 pub import_external_credentials: bool,
18}
19
20pub fn choose(
25 request: &ModelRequest<'_>,
26 settings: &Settings,
27 registry: &Registry,
28) -> Result<Option<(Model, Option<ThinkingLevel>)>> {
29 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 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
83pub 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 ®istry,
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 ®istry,
159 );
160 assert_eq!(
161 (model.provider.as_str(), thinking),
162 ("openai", ThinkingLevel::Low)
163 );
164
165 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 ®istry,
183 );
184 assert_eq!(thinking, ThinkingLevel::Off);
185 }
186}