feature: add minimax_cn provider (#2701)

Co-authored-by: Amit Singh <amitksingh1490@gmail.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

crates/forge_app/src/infra.rs

@@ -354,7 +354,7 @@ pub trait StrategyFactory: Send + Sync {
         &self,
         provider_id: forge_domain::ProviderId,
         auth_method: forge_domain::AuthMethod,
-        required_params: Vec<forge_domain::URLParam>,
+        required_params: Vec<forge_domain::URLParamSpec>,
     ) -> anyhow::Result<Self::Strategy>;
 }
 

crates/forge_domain/src/auth/auth_context.rs

@@ -5,7 +5,7 @@ use url::Url;
 
 use super::{
     ApiKey, AuthorizationCode, DeviceCode, OAuthConfig, PkceVerifier, State, URLParam,
-    URLParamValue, UserCode,
+    URLParamSpec, URLParamValue, UserCode,
 };
 
 #[derive(Debug, Clone, PartialEq, Deref, From)]
@@ -16,7 +16,7 @@ pub struct URLParameters(HashMap<URLParam, URLParamValue>);
 /// Request parameters for API key authentication
 #[derive(Debug, Clone)]
 pub struct ApiKeyRequest {
-    pub required_params: Vec<URLParam>,
+    pub required_params: Vec<URLParamSpec>,
     pub existing_params: Option<URLParameters>,
     pub api_key: Option<ApiKey>,
 }

crates/forge_domain/src/auth/new_types.rs

@@ -76,6 +76,44 @@ pub struct URLParam(String);
 #[serde(transparent)]
 pub struct URLParamValue(String);
 
+/// A URL parameter specification with its name and optional preset options.
+///
+/// When `options` is `Some`, the UI presents a dropdown for selection.
+/// When `options` is `None`, the UI presents a free-text input.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct URLParamSpec {
+    /// The parameter name used as the template variable and credential map key.
+    pub name: URLParam,
+    /// Optional list of allowed values. When present, the UI renders a
+    /// dropdown.
+    pub options: Option<Vec<String>>,
+}
+
+impl URLParamSpec {
+    /// Creates a `URLParamSpec` with only a name, rendering as a free-text
+    /// input.
+    pub fn new(name: impl Into<URLParam>) -> Self {
+        Self { name: name.into(), options: None }
+    }
+
+    /// Creates a `URLParamSpec` with preset options, rendering as a dropdown.
+    pub fn with_options(name: impl Into<URLParam>, options: Vec<String>) -> Self {
+        Self { name: name.into(), options: Some(options) }
+    }
+}
+
+impl From<URLParam> for URLParamSpec {
+    fn from(name: URLParam) -> Self {
+        Self::new(name)
+    }
+}
+
+impl From<String> for URLParamSpec {
+    fn from(name: String) -> Self {
+        Self::new(URLParam::from(name))
+    }
+}
+
 #[derive(
     Clone,
     Serialize,

crates/forge_domain/src/provider.rs

@@ -211,7 +211,7 @@ pub struct Provider<T> {
     pub models: Option<ModelSource<T>>,
     pub auth_methods: Vec<crate::AuthMethod>,
     #[serde(default)]
-    pub url_params: Vec<crate::URLParam>,
+    pub url_params: Vec<crate::URLParamSpec>,
     pub credential: Option<AuthCredential>,
     /// Custom HTTP headers to include in API requests for this provider.
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -298,7 +298,7 @@ impl AnyProvider {
             AnyProvider::Template(_) => None,
         }
     }
-    pub fn url_params(&self) -> &[crate::URLParam] {
+    pub fn url_params(&self) -> &[crate::URLParamSpec] {
         match self {
             AnyProvider::Url(p) => &p.url_params,
             AnyProvider::Template(p) => &p.url_params,

crates/forge_infra/src/auth/strategy.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use forge_app::{AuthStrategy, OAuthHttpProvider, StrategyFactory};
 use forge_domain::{
     ApiKey, ApiKeyRequest, AuthContextRequest, AuthContextResponse, AuthCredential, CodeRequest,
-    DeviceCodeRequest, OAuthConfig, OAuthTokenResponse, OAuthTokens, ProviderId, URLParam,
+    DeviceCodeRequest, OAuthConfig, OAuthTokenResponse, OAuthTokens, ProviderId, URLParamSpec,
 };
 use google_cloud_auth::credentials::Builder;
 use oauth2::basic::BasicClient;
@@ -18,11 +18,11 @@ use crate::auth::util::*;
 /// API Key Strategy - Simple static key authentication
 pub struct ApiKeyStrategy {
     provider_id: ProviderId,
-    required_params: Vec<URLParam>,
+    required_params: Vec<URLParamSpec>,
 }
 
 impl ApiKeyStrategy {
-    pub fn new(provider_id: ProviderId, required_params: Vec<URLParam>) -> Self {
+    pub fn new(provider_id: ProviderId, required_params: Vec<URLParamSpec>) -> Self {
         Self { provider_id, required_params }
     }
 }
@@ -348,11 +348,11 @@ impl AuthStrategy for OAuthWithApiKeyStrategy {
 /// Uses Google Cloud SDK's ADC mechanism with automatic token refresh
 pub struct GoogleAdcStrategy {
     provider_id: ProviderId,
-    required_params: Vec<URLParam>,
+    required_params: Vec<URLParamSpec>,
 }
 
 impl GoogleAdcStrategy {
-    pub fn new(provider_id: ProviderId, required_params: Vec<URLParam>) -> Self {
+    pub fn new(provider_id: ProviderId, required_params: Vec<URLParamSpec>) -> Self {
         Self { provider_id, required_params }
     }
 }
@@ -1036,7 +1036,7 @@ impl StrategyFactory for ForgeAuthStrategyFactory {
         &self,
         provider_id: ProviderId,
         auth_method: forge_domain::AuthMethod,
-        required_params: Vec<URLParam>,
+        required_params: Vec<URLParamSpec>,
     ) -> anyhow::Result<Self::Strategy> {
         match auth_method {
             forge_domain::AuthMethod::ApiKey => Ok(AnyAuthStrategy::ApiKey(ApiKeyStrategy::new(
@@ -1093,6 +1093,7 @@ impl StrategyFactory for ForgeAuthStrategyFactory {
 mod tests {
     use std::collections::HashMap;
 
+    use forge_domain::URLParam;
     use pretty_assertions::assert_eq;
 
     use super::*;

crates/forge_infra/src/forge_infra.rs

@@ -10,7 +10,7 @@ use forge_app::{
     StrategyFactory, UserInfra, WalkerInfra,
 };
 use forge_domain::{
-    AuthMethod, CommandOutput, FileInfo as FileInfoData, McpServerConfig, ProviderId, URLParam,
+    AuthMethod, CommandOutput, FileInfo as FileInfoData, McpServerConfig, ProviderId, URLParamSpec,
 };
 use reqwest::header::HeaderMap;
 use reqwest::{Response, Url};
@@ -312,7 +312,7 @@ impl StrategyFactory for ForgeInfra {
         &self,
         provider_id: ProviderId,
         method: AuthMethod,
-        required_params: Vec<URLParam>,
+        required_params: Vec<URLParamSpec>,
     ) -> anyhow::Result<Self::Strategy> {
         self.strategy_factory
             .create_auth_strategy(provider_id, method, required_params)

crates/forge_main/src/ui.rs

@@ -2193,22 +2193,39 @@ impl<A: API + ConsoleWriter + 'static, F: Fn() -> A + Send + Sync> UI<A, F> {
             .required_params
             .iter()
             .map(|param| {
-                let mut input = ForgeWidget::input(format!("Enter {param}"));
-
-                // Add default value if it exists in the credential
-                if let Some(params) = existing_url_params
-                    && let Some(default_value) = params.get(param)
-                {
-                    input = input.with_default(default_value.as_str());
-                }
+                let param_value = if let Some(options) = &param.options {
+                    // Dropdown path: user selects from preset options
+                    let starting = existing_url_params
+                        .and_then(|p| p.get(&param.name))
+                        .and_then(|v| options.iter().position(|o| o.as_str() == v.as_str()))
+                        .unwrap_or(0);
+                    ForgeWidget::select(format!("Select {}", param.name), options.clone())
+                        .with_starting_cursor(starting)
+                        .prompt()?
+                        .context("Parameter selection cancelled")?
+                } else {
+                    // Free-text path (existing behavior)
+                    let mut input = ForgeWidget::input(format!("Enter {}", param.name));
+
+                    // Add default value if it exists in the credential
+                    if let Some(params) = existing_url_params
+                        && let Some(default_value) = params.get(&param.name)
+                    {
+                        input = input.with_default(default_value.as_str());
+                    }
 
-                let param_value = input.prompt()?.context("Parameter input cancelled")?;
+                    let param_value = input.prompt()?.context("Parameter input cancelled")?;
 
-                anyhow::ensure!(!param_value.trim().is_empty(), "{param} cannot be empty");
+                    anyhow::ensure!(
+                        !param_value.trim().is_empty(),
+                        "{} cannot be empty",
+                        param.name
+                    );
 
-                let param_value = param_value.trim_end_matches('/').to_string();
+                    param_value.trim_end_matches('/').to_string()
+                };
 
-                Ok((param.to_string(), param_value))
+                Ok((param.name.to_string(), param_value))
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 

crates/forge_repo/src/forge_repo.rs

@@ -480,7 +480,7 @@ impl<F: StrategyFactory> StrategyFactory for ForgeRepo<F> {
         &self,
         provider_id: ProviderId,
         auth_method: forge_domain::AuthMethod,
-        required_params: Vec<forge_domain::URLParam>,
+        required_params: Vec<forge_domain::URLParamSpec>,
     ) -> anyhow::Result<Self::Strategy> {
         self.infra
             .create_auth_strategy(provider_id, auth_method, required_params)

crates/forge_repo/src/provider/provider.json

@@ -1851,9 +1851,9 @@
   {
     "id": "minimax",
     "api_key_vars": "MINIMAX_API_KEY",
-    "url_param_vars": [],
+    "url_param_vars": [{"name": "MINIMAX_DOMAIN", "options": ["api.minimax.io", "api.minimaxi.com"]}],
     "response_type": "Anthropic",
-    "url": "https://api.minimax.io/anthropic/v1/messages",
+    "url": "https://{{#if MINIMAX_DOMAIN}}{{MINIMAX_DOMAIN}}{{else}}api.minimax.io{{/if}}/anthropic/v1/messages",
     "models": [
       {
         "id": "MiniMax-M2.7",