feat(proxy): add full URL mode and refactor endpoint rewriting

- Add `isFullUrl` provider meta to treat base_url as complete API endpoint
- Remove hardcoded `?beta=true` from Claude adapter, pass through from client
- Refactor forwarder endpoint rewriting with proper query string handling
- Block provider switching when proxy is required but not running
- Add full URL toggle UI in endpoint field with i18n (zh/en/ja)

src-tauri/src/provider.rs

@@ -245,6 +245,9 @@ pub struct ProviderMeta {
     /// Claude 认证字段名（"ANTHROPIC_AUTH_TOKEN" 或 "ANTHROPIC_API_KEY"）
     #[serde(rename = "apiKeyField", skip_serializing_if = "Option::is_none")]
     pub api_key_field: Option<String>,
+    /// 是否将 base_url 视为完整 API 端点（不拼接 endpoint 路径）
+    #[serde(rename = "isFullUrl", skip_serializing_if = "Option::is_none")]
+    pub is_full_url: Option<bool>,
     /// Prompt cache key for OpenAI-compatible endpoints.
     /// When set, injected into converted requests to improve cache hit rate.
     /// If not set, provider ID is used automatically during format conversion.

src-tauri/src/proxy/forwarder.rs

@@ -792,21 +792,30 @@ impl RequestForwarder {
         // 检查是否需要格式转换
         let needs_transform = adapter.needs_transform(provider);
 
-        let effective_endpoint =
-            if needs_transform && adapter.name() == "Claude" && endpoint == "/v1/messages" {
-                // 根据 api_format 选择目标端点
+        let is_full_url = provider
+            .meta
+            .as_ref()
+            .and_then(|meta| meta.is_full_url)
+            .unwrap_or(false);
+
+        let (effective_endpoint, passthrough_query) =
+            if needs_transform && adapter.name() == "Claude" {
                 let api_format = super::providers::get_claude_api_format(provider);
-                if api_format == "openai_responses" {
-                    "/v1/responses"
-                } else {
-                    "/v1/chat/completions"
-                }
+                rewrite_claude_transform_endpoint(endpoint, &api_format)
             } else {
-                endpoint
+                (
+                    endpoint.to_string(),
+                    split_endpoint_and_query(endpoint)
+                        .1
+                        .map(ToString::to_string),
+                )
             };
 
-        // 使用适配器构建 URL
-        let url = adapter.build_url(&base_url, effective_endpoint);
+        let url = if is_full_url {
+            append_query_to_full_url(&base_url, passthrough_query.as_deref())
+        } else {
+            adapter.build_url(&base_url, &effective_endpoint)
+        };
 
         // 应用模型映射（独立于格式转换）
         let (mapped_body, _original_model, _mapped_model) =
@@ -887,7 +896,7 @@ impl RequestForwarder {
 
         // 流式请求保守禁用压缩，避免上游压缩 SSE 在连接中断时触发解压错误。
         // 非流式请求不显式设置 Accept-Encoding，让 reqwest 自动协商压缩并透明解压。
-        if should_force_identity_encoding(effective_endpoint, &filtered_body, headers) {
+        if should_force_identity_encoding(&effective_endpoint, &filtered_body, headers) {
             request = request.header("accept-encoding", "identity");
         }
 
@@ -1094,6 +1103,70 @@ fn extract_json_error_message(body: &Value) -> Option<String> {
         .find_map(|value| value.as_str().map(ToString::to_string))
 }
 
+fn split_endpoint_and_query(endpoint: &str) -> (&str, Option<&str>) {
+    endpoint
+        .split_once('?')
+        .map_or((endpoint, None), |(path, query)| (path, Some(query)))
+}
+
+fn filter_beta_query(query: Option<&str>) -> Option<String> {
+    let filtered = query.map(|query| {
+        query
+            .split('&')
+            .filter(|pair| !pair.is_empty() && !pair.starts_with("beta="))
+            .collect::<Vec<_>>()
+            .join("&")
+    });
+
+    match filtered.as_deref() {
+        Some("") | None => None,
+        Some(_) => filtered,
+    }
+}
+
+fn is_claude_messages_path(path: &str) -> bool {
+    matches!(path, "/v1/messages" | "/claude/v1/messages")
+}
+
+fn rewrite_claude_transform_endpoint(endpoint: &str, api_format: &str) -> (String, Option<String>) {
+    let (path, query) = split_endpoint_and_query(endpoint);
+    let filtered_query = if is_claude_messages_path(path) {
+        filter_beta_query(query)
+    } else {
+        query.map(ToString::to_string)
+    };
+
+    if !is_claude_messages_path(path) {
+        return (endpoint.to_string(), filtered_query);
+    }
+
+    let target_path = if api_format == "openai_responses" {
+        "/v1/responses"
+    } else {
+        "/v1/chat/completions"
+    };
+
+    let rewritten = match filtered_query.as_deref() {
+        Some(query) if !query.is_empty() => format!("{target_path}?{query}"),
+        _ => target_path.to_string(),
+    };
+
+    (rewritten, filtered_query)
+}
+
+fn append_query_to_full_url(base_url: &str, query: Option<&str>) -> String {
+    match query {
+        Some(query) if !query.is_empty() => {
+            if base_url.contains('?') {
+                format!("{base_url}&{query}")
+            } else {
+                format!("{base_url}?{query}")
+            }
+        }
+        _ => base_url.to_string(),
+    }
+}
+
 fn should_force_identity_encoding(
     endpoint: &str,
     body: &Value,
@@ -1202,6 +1275,33 @@ mod tests {
         assert_eq!(summary, "line1 line2...");
     }
 
+    #[test]
+    fn rewrite_claude_transform_endpoint_strips_beta_for_chat_completions() {
+        let (endpoint, passthrough_query) =
+            rewrite_claude_transform_endpoint("/v1/messages?beta=true&foo=bar", "openai_chat");
+
+        assert_eq!(endpoint, "/v1/chat/completions?foo=bar");
+        assert_eq!(passthrough_query.as_deref(), Some("foo=bar"));
+    }
+
+    #[test]
+    fn rewrite_claude_transform_endpoint_strips_only_beta_for_responses() {
+        let (endpoint, passthrough_query) = rewrite_claude_transform_endpoint(
+            "/claude/v1/messages?beta=true&x-id=1",
+            "openai_responses",
+        );
+
+        assert_eq!(endpoint, "/v1/responses?x-id=1");
+        assert_eq!(passthrough_query.as_deref(), Some("x-id=1"));
+    }
+
+    #[test]
+    fn append_query_to_full_url_preserves_existing_query_string() {
+        let url = append_query_to_full_url("https://relay.example/api?foo=bar", Some("x-id=1"));
+
+        assert_eq!(url, "https://relay.example/api?foo=bar&x-id=1");
+    }
+
     #[test]
     fn force_identity_for_stream_flag_requests() {
         let headers = HeaderMap::new();

src-tauri/src/proxy/handlers.rs

@@ -61,12 +61,18 @@ pub async fn get_status(State(state): State<ProxyState>) -> Result<Json<ProxySta
 /// - 现在 OpenRouter 已推出 Claude Code 兼容接口，默认不再启用该转换（逻辑保留以备回退）
 pub async fn handle_messages(
     State(state): State<ProxyState>,
+    uri: axum::http::Uri,
     headers: axum::http::HeaderMap,
     Json(body): Json<Value>,
 ) -> Result<axum::response::Response, ProxyError> {
     let mut ctx =
         RequestContext::new(&state, &body, &headers, AppType::Claude, "Claude", "claude").await?;
 
+    let endpoint = uri
+        .path_and_query()
+        .map(|path_and_query| path_and_query.as_str())
+        .unwrap_or(uri.path());
+
     let is_stream = body
         .get("stream")
         .and_then(|s| s.as_bool())
@@ -77,7 +83,7 @@ pub async fn handle_messages(
     let result = match forwarder
         .forward_with_retry(
             &AppType::Claude,
-            "/v1/messages",
+            endpoint,
             body.clone(),
             headers,
             ctx.get_providers(),

src-tauri/src/proxy/providers/claude.rs

@@ -261,6 +261,8 @@ impl ProviderAdapter for ClaudeAdapter {
         //
         // 现在 OpenRouter 已推出 Claude Code 兼容接口，因此默认直接透传 endpoint。
         // 如需回退旧逻辑，可在 forwarder 中根据 needs_transform 改写 endpoint。
+        //
+        // `?beta=true` 由客户端请求决定，代理不再硬编码追加。
 
         let mut base = format!(
             "{}/{}",
@@ -273,19 +275,7 @@ impl ProviderAdapter for ClaudeAdapter {
             base = base.replace("/v1/v1", "/v1");
         }
 
-        // 为 Claude 原生 /v1/messages 端点添加 ?beta=true 参数
-        // 这是某些上游服务（如 DuckCoding）验证请求来源的关键参数
-        // 注意：不要为 OpenAI Chat Completions (/v1/chat/completions) 添加此参数
-        //       当 apiFormat="openai_chat" 时，请求会转发到 /v1/chat/completions，
-        //       但该端点是 OpenAI 标准，不支持 ?beta=true 参数
-        if endpoint.contains("/v1/messages")
-            && !endpoint.contains("/v1/chat/completions")
-            && !endpoint.contains('?')
-        {
-            format!("{base}?beta=true")
-        } else {
-            base
-        }
+        base
     }
 
     fn add_auth_headers(&self, request: RequestBuilder, auth: &AuthInfo) -> RequestBuilder {
@@ -522,23 +512,20 @@ mod tests {
     #[test]
     fn test_build_url_anthropic() {
         let adapter = ClaudeAdapter::new();
-        // /v1/messages 端点会自动添加 ?beta=true 参数
         let url = adapter.build_url("https://api.anthropic.com", "/v1/messages");
-        assert_eq!(url, "https://api.anthropic.com/v1/messages?beta=true");
+        assert_eq!(url, "https://api.anthropic.com/v1/messages");
     }
 
     #[test]
     fn test_build_url_openrouter() {
         let adapter = ClaudeAdapter::new();
-        // /v1/messages 端点会自动添加 ?beta=true 参数
         let url = adapter.build_url("https://openrouter.ai/api", "/v1/messages");
-        assert_eq!(url, "https://openrouter.ai/api/v1/messages?beta=true");
+        assert_eq!(url, "https://openrouter.ai/api/v1/messages");
     }
 
     #[test]
     fn test_build_url_no_beta_for_other_endpoints() {
         let adapter = ClaudeAdapter::new();
-        // 非 /v1/messages 端点不添加 ?beta=true
         let url = adapter.build_url("https://api.anthropic.com", "/v1/complete");
         assert_eq!(url, "https://api.anthropic.com/v1/complete");
     }
@@ -546,9 +533,8 @@ mod tests {
     #[test]
     fn test_build_url_preserve_existing_query() {
         let adapter = ClaudeAdapter::new();
-        // 已有查询参数时不重复添加
-        let url = adapter.build_url("https://api.anthropic.com", "/v1/messages?foo=bar");
-        assert_eq!(url, "https://api.anthropic.com/v1/messages?foo=bar");
+        let url = adapter.build_url("https://api.anthropic.com", "/v1/messages?beta=true");
+        assert_eq!(url, "https://api.anthropic.com/v1/messages?beta=true");
     }
 
     #[test]

src-tauri/src/services/stream_check.rs

@@ -312,22 +312,12 @@ impl StreamCheckService {
             .unwrap_or("anthropic");
 
         let is_openai_chat = api_format == "openai_chat";
-
-        // URL: /v1/chat/completions for openai_chat, /v1/messages?beta=true for anthropic
-        let url = if is_openai_chat {
-            if base.ends_with("/v1") {
-                format!("{base}/chat/completions")
-            } else {
-                format!("{base}/v1/chat/completions")
-            }
-        } else {
-            // ?beta=true is required by some relay services to verify request origin
-            if base.ends_with("/v1") {
-                format!("{base}/messages?beta=true")
-            } else {
-                format!("{base}/v1/messages?beta=true")
-            }
-        };
+        let is_full_url = provider
+            .meta
+            .as_ref()
+            .and_then(|meta| meta.is_full_url)
+            .unwrap_or(false);
+        let url = Self::build_claude_stream_check_url(base, is_openai_chat, is_full_url);
 
         // Body: identical structure for minimal test (both APIs accept messages array)
         let body = json!({
@@ -692,6 +682,28 @@ impl StreamCheckService {
             other => other,
         }
     }
+
+    fn build_claude_stream_check_url(
+        base_url: &str,
+        is_openai_chat: bool,
+        is_full_url: bool,
+    ) -> String {
+        if is_full_url {
+            return base_url.to_string();
+        }
+
+        if is_openai_chat {
+            if base_url.ends_with("/v1") {
+                format!("{base_url}/chat/completions")
+            } else {
+                format!("{base_url}/v1/chat/completions")
+            }
+        } else if base_url.ends_with("/v1") {
+            format!("{base_url}/messages?beta=true")
+        } else {
+            format!("{base_url}/v1/messages?beta=true")
+        }
+    }
 }
 
 #[cfg(test)]
@@ -794,4 +806,37 @@ mod tests {
         assert_eq!(claude_auth, AuthStrategy::ClaudeAuth);
         assert_eq!(bearer, AuthStrategy::Bearer);
     }
+
+    #[test]
+    fn test_build_claude_stream_check_url_for_full_url_mode() {
+        let url = StreamCheckService::build_claude_stream_check_url(
+            "https://relay.example/v1/chat/completions",
+            true,
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/v1/chat/completions");
+    }
+
+    #[test]
+    fn test_build_claude_stream_check_url_for_openai_chat() {
+        let url = StreamCheckService::build_claude_stream_check_url(
+            "https://relay.example/v1",
+            true,
+            false,
+        );
+
+        assert_eq!(url, "https://relay.example/v1/chat/completions");
+    }
+
+    #[test]
+    fn test_build_claude_stream_check_url_for_anthropic() {
+        let url = StreamCheckService::build_claude_stream_check_url(
+            "https://relay.example",
+            false,
+            false,
+        );
+
+        assert_eq!(url, "https://relay.example/v1/messages?beta=true");
+    }
 }