[model-gateway] add audio and moderation in model card (sgl-project#14263)

Author: slin1237

sgl-router/src/core/model_card.rs

@@ -321,229 +321,3 @@ impl std::fmt::Display for ModelCard {
         write!(f, "{}", self.name())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_card_new() {
-        let card = ModelCard::new("llama-3.1-8b");
-        assert_eq!(card.id, "llama-3.1-8b");
-        assert_eq!(card.model_type, ModelType::LLM);
-        assert!(card.provider.is_none()); // Native by default
-        assert!(card.aliases.is_empty());
-    }
-
-    #[test]
-    fn test_model_card_builder() {
-        let card = ModelCard::new("meta-llama/Llama-3.1-8B-Instruct")
-            .with_display_name("Llama 3.1 8B")
-            .with_alias("llama-3.1-8b")
-            .with_alias("llama3.1")
-            .with_model_type(ModelType::VISION_LLM)
-            .with_context_length(128_000)
-            .with_tokenizer_path("meta-llama/Llama-3.1-8B-Instruct")
-            .with_reasoning_parser("deepseek")
-            .with_tool_parser("llama");
-
-        assert_eq!(card.name(), "Llama 3.1 8B");
-        assert_eq!(card.aliases.len(), 2);
-        assert!(card.supports_vision());
-        assert_eq!(card.context_length, Some(128_000));
-        assert_eq!(
-            card.tokenizer_path.as_deref(),
-            Some("meta-llama/Llama-3.1-8B-Instruct")
-        );
-        assert_eq!(card.reasoning_parser.as_deref(), Some("deepseek"));
-        assert_eq!(card.tool_parser.as_deref(), Some("llama"));
-        assert!(card.is_native()); // No provider set
-    }
-
-    #[test]
-    fn test_model_card_with_provider() {
-        let card = ModelCard::new("gpt-4o").with_provider(ProviderType::OpenAI);
-
-        assert!(card.has_external_provider());
-        assert!(!card.is_native());
-        assert_eq!(card.provider, Some(ProviderType::OpenAI));
-    }
-
-    #[test]
-    fn test_model_card_matches() {
-        let card = ModelCard::new("gpt-4o")
-            .with_alias("gpt-4o-2024-08-06")
-            .with_alias("gpt-4-turbo");
-
-        assert!(card.matches("gpt-4o"));
-        assert!(card.matches("gpt-4o-2024-08-06"));
-        assert!(card.matches("gpt-4-turbo"));
-        assert!(!card.matches("gpt-3.5"));
-    }
-
-    #[test]
-    fn test_model_card_supports_endpoint() {
-        let llm = ModelCard::new("llama").with_model_type(ModelType::LLM);
-        assert!(llm.supports_endpoint(Endpoint::Chat));
-        assert!(llm.supports_endpoint(Endpoint::Completions));
-        assert!(!llm.supports_endpoint(Endpoint::Embeddings));
-
-        let embed = ModelCard::new("bge").with_model_type(ModelType::EMBED_MODEL);
-        assert!(embed.supports_endpoint(Endpoint::Embeddings));
-        assert!(!embed.supports_endpoint(Endpoint::Chat));
-    }
-
-    #[test]
-    fn test_model_card_name_fallback() {
-        let card_with_name = ModelCard::new("model-id").with_display_name("Display Name");
-        assert_eq!(card_with_name.name(), "Display Name");
-
-        let card_without_name = ModelCard::new("model-id");
-        assert_eq!(card_without_name.name(), "model-id");
-    }
-
-    #[test]
-    fn test_model_card_is_llm() {
-        let llm = ModelCard::new("llama").with_model_type(ModelType::LLM);
-        assert!(llm.is_llm());
-
-        let embed = ModelCard::new("bge").with_model_type(ModelType::EMBED_MODEL);
-        assert!(!embed.is_llm());
-    }
-
-    #[test]
-    fn test_model_card_default() {
-        let card = ModelCard::default();
-        assert_eq!(card.id, "default");
-        assert_eq!(card.model_type, ModelType::LLM);
-        assert!(card.provider.is_none());
-    }
-
-    #[test]
-    fn test_model_card_serialization() {
-        let card = ModelCard::new("gpt-4o")
-            .with_display_name("GPT-4o")
-            .with_alias("gpt4o")
-            .with_provider(ProviderType::OpenAI)
-            .with_context_length(128_000);
-
-        let json = serde_json::to_string(&card).unwrap();
-        let deserialized: ModelCard = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(deserialized.id, "gpt-4o");
-        assert_eq!(deserialized.display_name, Some("GPT-4o".to_string()));
-        assert_eq!(deserialized.aliases, vec!["gpt4o"]);
-        assert_eq!(deserialized.provider, Some(ProviderType::OpenAI));
-        assert_eq!(deserialized.context_length, Some(128_000));
-    }
-
-    #[test]
-    fn test_model_card_serialization_native() {
-        // Native model (no provider) should not include provider in JSON
-        let card = ModelCard::new("llama-3.1");
-        let json = serde_json::to_string(&card).unwrap();
-
-        // Provider should be omitted from JSON when None
-        assert!(!json.contains("provider"));
-
-        let deserialized: ModelCard = serde_json::from_str(&json).unwrap();
-        assert!(deserialized.provider.is_none());
-    }
-
-    #[test]
-    fn test_model_card_display() {
-        let card = ModelCard::new("model-id").with_display_name("Display Name");
-        assert_eq!(format!("{}", card), "Display Name");
-    }
-
-    // === ProviderType tests ===
-
-    #[test]
-    fn test_provider_type_as_str() {
-        assert_eq!(ProviderType::OpenAI.as_str(), "openai");
-        assert_eq!(ProviderType::XAI.as_str(), "xai");
-        assert_eq!(ProviderType::Anthropic.as_str(), "anthropic");
-        assert_eq!(ProviderType::Gemini.as_str(), "gemini");
-        assert_eq!(
-            ProviderType::Custom("my-provider".to_string()).as_str(),
-            "my-provider"
-        );
-    }
-
-    #[test]
-    fn test_provider_type_from_model_name() {
-        // External providers
-        assert_eq!(
-            ProviderType::from_model_name("grok-beta"),
-            Some(ProviderType::XAI)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("Grok-2"),
-            Some(ProviderType::XAI)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("gemini-pro"),
-            Some(ProviderType::Gemini)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("claude-3-opus"),
-            Some(ProviderType::Anthropic)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("gpt-4o"),
-            Some(ProviderType::OpenAI)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("o1-preview"),
-            Some(ProviderType::OpenAI)
-        );
-        assert_eq!(
-            ProviderType::from_model_name("o3-mini"),
-            Some(ProviderType::OpenAI)
-        );
-
-        // Native/local models - no provider
-        assert_eq!(ProviderType::from_model_name("llama-3.1"), None);
-        assert_eq!(ProviderType::from_model_name("mistral-7b"), None);
-        assert_eq!(ProviderType::from_model_name("deepseek-r1"), None);
-        assert_eq!(ProviderType::from_model_name("qwen-2.5"), None);
-    }
-
-    #[test]
-    fn test_provider_type_serialization() {
-        // Test standard variants
-        let openai = ProviderType::OpenAI;
-        let json = serde_json::to_string(&openai).unwrap();
-        assert_eq!(json, "\"openai\"");
-        let deserialized: ProviderType = serde_json::from_str(&json).unwrap();
-        assert_eq!(deserialized, ProviderType::OpenAI);
-
-        // Test custom variant
-        let custom = ProviderType::Custom("my-provider".to_string());
-        let json = serde_json::to_string(&custom).unwrap();
-        let deserialized: ProviderType = serde_json::from_str(&json).unwrap();
-        assert_eq!(
-            deserialized,
-            ProviderType::Custom("my-provider".to_string())
-        );
-    }
-
-    #[test]
-    fn test_provider_type_aliases() {
-        // Test serde aliases
-        let xai: ProviderType = serde_json::from_str("\"grok\"").unwrap();
-        assert_eq!(xai, ProviderType::XAI);
-
-        let anthropic: ProviderType = serde_json::from_str("\"claude\"").unwrap();
-        assert_eq!(anthropic, ProviderType::Anthropic);
-
-        let gemini: ProviderType = serde_json::from_str("\"google\"").unwrap();
-        assert_eq!(gemini, ProviderType::Gemini);
-    }
-
-    #[test]
-    fn test_provider_type_display() {
-        assert_eq!(format!("{}", ProviderType::OpenAI), "openai");
-        assert_eq!(format!("{}", ProviderType::XAI), "xai");
-    }
-}