Skip to main content

reflex/pulse/write/
provider.rs

1//! Resolve which LLM the writing pass talks to.
2
3use 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/// Provider and model: the identity that goes into every cache key.
11#[derive(Debug, Clone, PartialEq, Eq)]
12pub struct ModelIdent {
13    pub provider: String,
14    pub model: String,
15}
16
17/// What the writing pass may use this run.
18#[derive(Clone, Default)]
19pub struct LlmHandle {
20    /// Identity for cache keys. Set whenever a provider is configured, even without a key.
21    pub ident: Option<ModelIdent>,
22    /// A live provider, when `mode` is `On` and one could be built.
23    pub provider: Option<Arc<dyn LlmProvider>>,
24    /// Why no live provider exists, for the run summary.
25    pub unavailable: Option<String>,
26}
27
28impl LlmHandle {
29    /// A handle around an existing provider (tests, embedding).
30    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
42/// Build the handle for `mode`.
43///
44/// - `Off`: empty.
45/// - `CacheOnly`: identity from config only. No API key is needed, so fork PRs in CI
46///   can reuse a cache that a trusted run filled.
47/// - `On`: a live provider. If the configured provider has no key, the first provider
48///   that has one is used instead (CI often sets only `OPENROUTER_API_KEY`).
49pub 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
81/// Model for `provider`. The configured model names apply only to the configured
82/// provider; an auto-detected fallback uses its own `[credentials]` model or default.
83fn 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
100/// The identity a live provider would report, without building it.
101fn 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
114/// Provider names as `LlmProvider::name` reports them.
115fn 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            // Keyless local endpoints count only when a base URL is configured.
131            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}