reflex/pulse/write/
provider.rs1use super::LlmMode;
4use crate::pulse::config::WriteSettings;
5use crate::semantic::config;
6use crate::semantic::providers::{self, LlmProvider};
7use std::path::Path;
8use std::sync::Arc;
9
10#[derive(Debug, Clone, PartialEq, Eq)]
12pub struct ModelIdent {
13 pub provider: String,
14 pub model: String,
15}
16
17#[derive(Clone, Default)]
19pub struct LlmHandle {
20 pub ident: Option<ModelIdent>,
22 pub provider: Option<Arc<dyn LlmProvider>>,
24 pub unavailable: Option<String>,
26}
27
28impl LlmHandle {
29 pub fn from_provider(provider: Arc<dyn LlmProvider>) -> Self {
31 Self {
32 ident: Some(ModelIdent {
33 provider: provider.name().to_string(),
34 model: provider.model().to_string(),
35 }),
36 provider: Some(provider),
37 unavailable: None,
38 }
39 }
40}
41
42pub fn resolve(mode: LlmMode, settings: &WriteSettings) -> LlmHandle {
50 match mode {
51 LlmMode::Off => LlmHandle::default(),
52 LlmMode::CacheOnly => match configured_ident(settings) {
53 Ok(ident) => LlmHandle {
54 ident: Some(ident),
55 provider: None,
56 unavailable: Some("cache-only mode".into()),
57 },
58 Err(e) => LlmHandle {
59 unavailable: Some(e.to_string()),
60 ..Default::default()
61 },
62 },
63 LlmMode::On => match create_provider(settings) {
64 Ok(p) => LlmHandle::from_provider(Arc::from(p)),
65 Err(e) => LlmHandle {
66 ident: configured_ident(settings).ok(),
67 provider: None,
68 unavailable: Some(e.to_string()),
69 },
70 },
71 }
72}
73
74fn configured_provider(settings: &WriteSettings) -> anyhow::Result<String> {
75 if let Some(p) = &settings.provider {
76 return Ok(p.clone());
77 }
78 Ok(config::load_config(Path::new("."))?.provider)
79}
80
81fn resolve_model(provider: &str, settings: &WriteSettings) -> anyhow::Result<Option<String>> {
84 let semantic = config::load_config(Path::new("."))?;
85 let configured = settings.provider.as_deref().unwrap_or(&semantic.provider);
86 if !provider.eq_ignore_ascii_case(configured) {
87 return Ok(config::resolve_model_for(provider, None, None));
88 }
89 let project_model = configured
90 .eq_ignore_ascii_case(&semantic.provider)
91 .then_some(semantic.model.as_deref())
92 .flatten();
93 Ok(config::resolve_model_for(
94 provider,
95 project_model,
96 settings.model.as_deref(),
97 ))
98}
99
100fn configured_ident(settings: &WriteSettings) -> anyhow::Result<ModelIdent> {
102 let provider = configured_provider(settings)?;
103 let model = resolve_model(&provider, settings)?
104 .unwrap_or_else(|| providers::default_model_for(&provider).to_string());
105 if model.is_empty() {
106 anyhow::bail!("no model configured for provider '{provider}'");
107 }
108 Ok(ModelIdent {
109 provider: canonical_name(&provider),
110 model,
111 })
112}
113
114fn canonical_name(provider: &str) -> String {
116 match provider.to_ascii_lowercase().as_str() {
117 "openai_compatible" => "openai-compatible".into(),
118 other => other.into(),
119 }
120}
121
122fn create_provider(settings: &WriteSettings) -> anyhow::Result<Box<dyn LlmProvider>> {
123 let semantic = config::load_config(Path::new("."))?;
124 let configured = configured_provider(settings)?;
125
126 let (provider, api_key) = match config::get_api_key(&configured) {
127 Ok(key) => (configured.clone(), key),
128 Err(configured_err) => {
129 let mut fallbacks: Vec<&str> = vec!["openrouter", "anthropic", "openai"];
130 if config::get_provider_options("openai-compatible").is_some() {
132 fallbacks.push("openai-compatible");
133 }
134 let mut found = None;
135 for candidate in fallbacks {
136 if candidate.eq_ignore_ascii_case(&configured) {
137 continue;
138 }
139 if let Ok(key) = config::get_api_key(candidate) {
140 eprintln!(
141 "Note: no API key for configured provider '{configured}', using auto-detected '{candidate}'"
142 );
143 found = Some((candidate.to_string(), key));
144 break;
145 }
146 }
147 found.ok_or(configured_err)?
148 }
149 };
150
151 let model = resolve_model(&provider, settings)?;
152 let options = config::get_provider_options(&provider);
153 providers::create_provider(&provider, api_key, model, options, semantic.timeout_seconds)
154}