#[allow(dead_code)]
pub mod cloud;
pub mod config;
pub mod continuedev;
pub mod cursor;
#[allow(dead_code)]
pub mod discovery;
pub mod ollama;
pub mod openai_compat;
#[allow(dead_code)]
pub mod session_format;
#[allow(unused_imports)]
pub use cloud::{CloudConversation, CloudMessage, CloudProvider, FetchOptions};
pub use config::ProviderType;
#[allow(unused_imports)]
pub use config::{IronBridgeConfig, ProviderConfig};
#[allow(unused_imports)]
pub use discovery::discover_all_providers;
#[allow(unused_imports)]
pub use session_format::{GenericMessage, GenericSession};
use crate::models::ChatSession;
use anyhow::Result;
use std::path::PathBuf;
const PROBE_TIMEOUT: std::time::Duration = std::time::Duration::from_millis(250);
fn probe_cache() -> &'static std::sync::Mutex<std::collections::HashMap<String, bool>> {
static CACHE: std::sync::OnceLock<std::sync::Mutex<std::collections::HashMap<String, bool>>> =
std::sync::OnceLock::new();
CACHE.get_or_init(Default::default)
}
fn host_and_port(endpoint: &str) -> Option<(String, u16)> {
let rest = endpoint
.trim()
.strip_prefix("http://")
.map(|r| (r, 80u16))
.or_else(|| {
endpoint
.trim()
.strip_prefix("https://")
.map(|r| (r, 443u16))
});
let (rest, default_port) = rest?;
let authority = rest.split(['/', '?', '#']).next()?;
if authority.is_empty() {
return None;
}
let authority = authority.rsplit('@').next()?;
if authority.starts_with('[') {
return None;
}
match authority.split_once(':') {
Some((host, port)) => Some((host.to_string(), port.parse().ok()?)),
None => Some((authority.to_string(), default_port)),
}
}
pub fn endpoint_is_listening(endpoint: &str) -> bool {
if let Ok(cache) = probe_cache().lock() {
if let Some(&known) = cache.get(endpoint) {
return known;
}
}
let listening = probe_endpoint(endpoint);
if let Ok(mut cache) = probe_cache().lock() {
cache.insert(endpoint.to_string(), listening);
}
listening
}
fn probe_endpoint(endpoint: &str) -> bool {
use std::net::{TcpStream, ToSocketAddrs};
let Some((host, port)) = host_and_port(endpoint) else {
return false;
};
let Ok(addrs) = (host.as_str(), port).to_socket_addrs() else {
return false;
};
addrs.into_iter().any(|addr| {
TcpStream::connect_timeout(&addr, PROBE_TIMEOUT)
.map(|stream| {
let _ = stream.shutdown(std::net::Shutdown::Both);
})
.is_ok()
})
}
pub trait ChatProvider: Send + Sync {
fn provider_type(&self) -> ProviderType;
fn name(&self) -> &str;
fn is_available(&self) -> bool;
fn sessions_path(&self) -> Option<PathBuf>;
fn list_sessions(&self) -> Result<Vec<ChatSession>>;
fn import_session(&self, session_id: &str) -> Result<ChatSession>;
#[allow(dead_code)]
fn export_session(&self, session: &ChatSession) -> Result<()>;
}
pub struct ProviderRegistry {
providers: Vec<Box<dyn ChatProvider>>,
}
impl ProviderRegistry {
pub fn new() -> Self {
let mut registry = Self {
providers: Vec::new(),
};
registry.discover_providers();
registry
}
fn discover_providers(&mut self) {
if let Some(provider) = cursor::CursorProvider::discover() {
self.providers.push(Box::new(provider));
}
if let Some(provider) = ollama::OllamaProvider::discover() {
self.providers.push(Box::new(provider));
}
for provider in openai_compat::discover_openai_compatible_providers() {
self.providers.push(Box::new(provider));
}
}
pub fn providers(&self) -> &[Box<dyn ChatProvider>] {
&self.providers
}
pub fn available_providers(&self) -> Vec<&dyn ChatProvider> {
self.providers
.iter()
.filter(|p| p.is_available())
.map(|p| p.as_ref())
.collect()
}
pub fn get_provider(&self, provider_type: ProviderType) -> Option<&dyn ChatProvider> {
self.providers
.iter()
.find(|p| p.provider_type() == provider_type)
.map(|p| p.as_ref())
}
#[allow(dead_code)]
pub fn list_all_sessions(&self) -> Result<Vec<(ProviderType, ChatSession)>> {
let mut all_sessions = Vec::new();
for provider in &self.providers {
if provider.is_available() {
if let Ok(sessions) = provider.list_sessions() {
for session in sessions {
all_sessions.push((provider.provider_type(), session));
}
}
}
}
Ok(all_sessions)
}
}
impl Default for ProviderRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod probe_tests {
use super::*;
use std::net::TcpListener;
#[test]
fn a_listening_port_is_detected() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
assert!(endpoint_is_listening(&format!("http://127.0.0.1:{port}")));
assert!(endpoint_is_listening(&format!(
"http://127.0.0.1:{port}/v1"
)));
}
#[test]
fn a_closed_port_is_not() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
assert!(!endpoint_is_listening(&format!("http://127.0.0.1:{port}")));
}
#[test]
fn the_old_behaviour_would_have_passed_both() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let dead = format!("http://127.0.0.1:{port}");
assert!(!dead.is_empty(), "the old check called this available");
assert!(!endpoint_is_listening(&dead), "the new one does not");
}
#[test]
fn a_malformed_endpoint_is_not_listening() {
for endpoint in [
"",
"localhost:11434", "ftp://localhost:21",
"http://",
"http://host:notaport",
"http://[::1]:8080", ] {
assert!(
!endpoint_is_listening(endpoint),
"{endpoint:?} should not report as listening"
);
}
}
#[test]
fn host_and_port_reads_the_shapes_these_providers_use() {
assert_eq!(
host_and_port("http://localhost:8000/v1"),
Some(("localhost".to_string(), 8000))
);
assert_eq!(
host_and_port("http://localhost"),
Some(("localhost".to_string(), 80))
);
assert_eq!(
host_and_port("https://api.example.com/v1"),
Some(("api.example.com".to_string(), 443))
);
assert_eq!(
host_and_port("http://user:pw@localhost:1234"),
Some(("localhost".to_string(), 1234))
);
assert_eq!(host_and_port("not a url"), None);
}
}