refactor(cli): move Provider enum from core to cli crate

Author: itzlambda

crates/rullm-cli/src/aliases.rs

@@ -1,5 +1,5 @@
+use super::provider::Provider;
 use rullm_core::error::LlmError;
-use rullm_core::providers::Provider;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::Path;

crates/rullm-cli/src/api_keys.rs

@@ -1,4 +1,5 @@
-use rullm_core::{Provider, error::LlmError};
+use crate::provider::Provider;
+use rullm_core::error::LlmError;
 use serde::{Deserialize, Serialize};
 use std::path::Path;
 

crates/rullm-cli/src/client.rs

@@ -1,8 +1,8 @@
+use super::provider::Provider;
 use crate::api_keys::ApiKeys;
 use crate::args::{Cli, CliConfig};
 use crate::constants;
 use anyhow::{Context, Result};
-use rullm_core::Provider;
 
 use rullm_core::simple::{SimpleLlmBuilder, SimpleLlmClient, SimpleLlmConfig};
 use rullm_core::{AnthropicConfig, GoogleAiConfig, LlmError, OpenAIConfig};

crates/rullm-cli/src/commands/keys.rs

@@ -2,12 +2,12 @@ use anyhow::Result;
 use clap::{Args, Subcommand};
 use strum::IntoEnumIterator;
 
+use crate::provider::Provider;
 use crate::{
     api_keys::ApiKeys,
     args::{Cli, CliConfig},
     output::OutputLevel,
 };
-use rullm_core::Provider;
 
 #[derive(Args)]
 pub struct KeysArgs {

crates/rullm-cli/src/main.rs

@@ -9,6 +9,7 @@ mod commands;
 mod config;
 mod constants;
 mod output;
+mod provider;
 
 use anyhow::Result;
 use args::{Cli, CliConfig};

crates/rullm-cli/src/provider.rs

@@ -0,0 +1,77 @@
+use clap::{ValueEnum, builder::PossibleValue};
+use strum::IntoEnumIterator;
+use strum_macros::EnumIter;
+
+#[derive(Clone, Debug, PartialEq, Eq, EnumIter)]
+pub enum Provider {
+    OpenAI,
+    Anthropic,
+    Google,
+}
+
+impl std::fmt::Display for Provider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let name = match self {
+            Provider::OpenAI => "openai",
+            Provider::Anthropic => "anthropic",
+            Provider::Google => "google",
+        };
+        write!(f, "{name}")
+    }
+}
+
+impl ValueEnum for Provider {
+    fn value_variants<'a>() -> &'a [Self] {
+        &[Self::OpenAI, Self::Anthropic, Self::Google]
+    }
+
+    fn to_possible_value(&self) -> Option<PossibleValue> {
+        let value = match self {
+            Self::OpenAI => PossibleValue::new("openai"),
+            Self::Anthropic => PossibleValue::new("anthropic"),
+            Self::Google => PossibleValue::new("google"),
+        };
+        Some(value)
+    }
+}
+
+impl Provider {
+    pub fn aliases(&self) -> &'static [&'static str] {
+        match self {
+            Provider::OpenAI => &["openai", "gpt"],
+            Provider::Anthropic => &["anthropic", "claude"],
+            Provider::Google => &["google", "gemini"],
+        }
+    }
+
+    pub fn from_alias(alias: &str) -> Option<Provider> {
+        let candidate = alias.to_ascii_lowercase();
+        Provider::iter().find(|p| p.aliases().contains(&candidate.as_str()))
+    }
+
+    #[allow(dead_code)]
+    pub fn from_model(input: &str) -> Result<(Provider, String), anyhow::Error> {
+        if let Some((provider_str, model)) = input.split_once('/') {
+            let provider = Provider::from_alias(provider_str)
+                .ok_or_else(|| anyhow::anyhow!(format!("Unsupported provider: {provider_str}")))?;
+
+            if model.is_empty() {
+                return Err(anyhow::anyhow!("Model name cannot be empty"));
+            }
+
+            Ok((provider, model.to_string()))
+        } else {
+            Err(anyhow::anyhow!(format!(
+                "Invalid model format '{input}'. Expected 'provider/model'"
+            )))
+        }
+    }
+
+    pub fn env_key(&self) -> &'static str {
+        match self {
+            Provider::OpenAI => "OPENAI_API_KEY",
+            Provider::Anthropic => "ANTHROPIC_API_KEY",
+            Provider::Google => "GOOGLE_AI_API_KEY",
+        }
+    }
+}

crates/rullm-core/src/lib.rs

@@ -156,7 +156,6 @@ mod tests;
 pub use config::{AnthropicConfig, ConfigBuilder, GoogleAiConfig, OpenAIConfig, ProviderConfig};
 pub use error::LlmError;
 pub use middleware::{LlmServiceBuilder, MiddlewareConfig, MiddlewareStack, RateLimit};
-pub use providers::Provider;
 pub use providers::{AnthropicProvider, GoogleProvider, OpenAIProvider};
 pub use simple::{DefaultModels, SimpleLlm, SimpleLlmBuilder, SimpleLlmClient, SimpleLlmConfig};
 pub use types::{

crates/rullm-core/src/providers/mod.rs

@@ -1,89 +1,7 @@
-// Re-export all providers
-pub mod anthropic;
-pub mod google;
-pub mod openai;
+mod anthropic;
+mod google;
+mod openai;
 
 pub use anthropic::AnthropicProvider;
 pub use google::GoogleProvider;
 pub use openai::OpenAIProvider;
-
-use clap::{ValueEnum, builder::PossibleValue};
-use strum::IntoEnumIterator;
-use strum_macros::EnumIter;
-
-/// Enum of supported providers usable throughout the library and by downstream
-/// crates (e.g. `rullm-cli`).  It is placed in the core crate so both the
-/// library and any front-end binaries share a single source of truth.
-#[derive(Clone, Debug, PartialEq, Eq, EnumIter)]
-pub enum Provider {
-    OpenAI,
-    Anthropic,
-    Google,
-}
-
-impl std::fmt::Display for Provider {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let name = match self {
-            Provider::OpenAI => "openai",
-            Provider::Anthropic => "anthropic",
-            Provider::Google => "google",
-        };
-        write!(f, "{name}")
-    }
-}
-
-impl ValueEnum for Provider {
-    fn value_variants<'a>() -> &'a [Self] {
-        &[Self::OpenAI, Self::Anthropic, Self::Google]
-    }
-
-    fn to_possible_value(&self) -> Option<PossibleValue> {
-        let value = match self {
-            Self::OpenAI => PossibleValue::new("openai"),
-            Self::Anthropic => PossibleValue::new("anthropic"),
-            Self::Google => PossibleValue::new("google"),
-        };
-        Some(value)
-    }
-}
-
-impl Provider {
-    // this part should be moved to cli
-    pub fn aliases(&self) -> &'static [&'static str] {
-        match self {
-            Provider::OpenAI => &["openai", "gpt"],
-            Provider::Anthropic => &["anthropic", "claude"],
-            Provider::Google => &["google", "gemini"],
-        }
-    }
-
-    // this part should be moved to cli
-    /// Attempt to resolve a provider from a string identifier (case-insensitive).
-    pub fn from_alias(alias: &str) -> Option<Provider> {
-        let candidate = alias.to_ascii_lowercase();
-        Provider::iter().find(|p| p.aliases().contains(&candidate.as_str()))
-    }
-
-    // this part should be moved to cli
-    /// Parse a model identifier in explicit provider/model format and return the provider
-    /// along with the model name (e.g. "openai/gpt-4" → (OpenAI, "gpt-4")).
-    pub fn from_model(input: &str) -> Result<(Provider, String), crate::error::LlmError> {
-        if let Some((provider_str, model)) = input.split_once('/') {
-            let provider = Provider::from_alias(provider_str).ok_or_else(|| {
-                crate::error::LlmError::validation(format!("Unsupported provider: {provider_str}"))
-            })?;
-
-            if model.is_empty() {
-                return Err(crate::error::LlmError::validation(
-                    "Model name cannot be empty".to_string(),
-                ));
-            }
-
-            Ok((provider, model.to_string()))
-        } else {
-            Err(crate::error::LlmError::validation(format!(
-                "Invalid model format '{input}'. Expected 'provider/model'"
-            )))
-        }
-    }
-}

crates/rullm-core/src/tests.rs

@@ -1386,114 +1386,3 @@ async fn test_middleware_performance_timing() {
     // The call should complete relatively quickly for a mock provider
     assert!(duration < Duration::from_secs(1));
 }
-
-#[cfg(test)]
-mod provider_from_model_tests {
-    use crate::providers::Provider;
-
-    #[test]
-    fn test_explicit_provider_prefixes() {
-        // Valid explicit prefixes
-        assert_eq!(
-            Provider::from_model("openai/gpt-4").unwrap(),
-            (Provider::OpenAI, "gpt-4".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("anthropic/claude-3-sonnet").unwrap(),
-            (Provider::Anthropic, "claude-3-sonnet".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("google/gemini-1.5-pro").unwrap(),
-            (Provider::Google, "gemini-1.5-pro".to_string())
-        );
-
-        // Test aliases as prefixes
-        assert_eq!(
-            Provider::from_model("gpt/gpt-4o-mini").unwrap(),
-            (Provider::OpenAI, "gpt-4o-mini".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("claude/claude-3-haiku").unwrap(),
-            (Provider::Anthropic, "claude-3-haiku".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("gemini/gemini-1.5-flash").unwrap(),
-            (Provider::Google, "gemini-1.5-flash".to_string())
-        );
-    }
-
-    #[test]
-    fn test_model_prefix_inference() {
-        // Core library now only supports explicit provider/model format
-        // Patterns without provider prefix should fail
-        assert!(Provider::from_model("gpt-4o-mini").is_err());
-        assert!(Provider::from_model("gpt-3.5-turbo").is_err());
-        assert!(Provider::from_model("gpt-4").is_err());
-        assert!(Provider::from_model("claude-3-5-sonnet-20241022").is_err());
-        assert!(Provider::from_model("claude-3-sonnet").is_err());
-        assert!(Provider::from_model("gemini-1.5-pro").is_err());
-        assert!(Provider::from_model("gemini-1.5-flash").is_err());
-    }
-
-    #[test]
-    fn test_unrecognized_model_patterns() {
-        // These should fail since they don't match our alias patterns or built-in aliases
-        // Note: o1-preview now succeeds due to built-in alias, so we test other patterns
-        assert!(Provider::from_model("text-davinci-003").is_err());
-        assert!(Provider::from_model("models/gemini-pro").is_err());
-        assert!(Provider::from_model("random-model-name").is_err());
-        assert!(Provider::from_model("unknown-prefix-model").is_err());
-    }
-
-    #[test]
-    fn test_built_in_aliases() {
-        // Core library no longer supports built-in aliases - they are CLI-specific
-        // All single-word inputs should fail as they need explicit provider/model format
-        assert!(Provider::from_model("gpt4").is_err());
-        assert!(Provider::from_model("chatgpt").is_err());
-        assert!(Provider::from_model("claude").is_err());
-        assert!(Provider::from_model("sonnet").is_err());
-        assert!(Provider::from_model("gemini").is_err());
-        assert!(Provider::from_model("o1-preview").is_err());
-    }
-
-    #[test]
-    fn test_case_insensitive_aliases() {
-        // Case insensitive provider prefix matching still works
-        assert_eq!(
-            Provider::from_model("OpenAI/gpt-4").unwrap(),
-            (Provider::OpenAI, "gpt-4".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("ANTHROPIC/claude-3-sonnet").unwrap(),
-            (Provider::Anthropic, "claude-3-sonnet".to_string())
-        );
-        assert_eq!(
-            Provider::from_model("Google/gemini-1.5-pro").unwrap(),
-            (Provider::Google, "gemini-1.5-pro".to_string())
-        );
-
-        // Single-word aliases are no longer supported in core
-        assert!(Provider::from_model("GPT4").is_err());
-        assert!(Provider::from_model("CLAUDE").is_err());
-    }
-
-    #[test]
-    fn test_error_cases() {
-        // Unknown provider prefix
-        assert!(Provider::from_model("unknown/some-model").is_err());
-        assert!(Provider::from_model("invalid-provider/model").is_err());
-        assert!(Provider::from_model("").is_err());
-    }
-
-    #[test]
-    fn test_provider_names_should_error() {
-        // All provider names should error in core since they don't use provider/model format
-        assert!(Provider::from_model("openai").is_err());
-        assert!(Provider::from_model("gpt").is_err());
-        assert!(Provider::from_model("anthropic").is_err());
-        assert!(Provider::from_model("google").is_err());
-        assert!(Provider::from_model("claude").is_err());
-        assert!(Provider::from_model("gemini").is_err());
-    }
-}