fix(proxy/gemini): prefer exact tool-call id over normalized-name fallback

The shadow-turn matcher used a three-branch `||` chain (id / full name /
normalized name). When two tools share a suffix (e.g. `server_a:search`
and `server_b:search`), the normalized-name clause could short-circuit
on an earlier turn whose id is actually wrong for the incoming tool_use,
mis-routing replay state (functionCall id / thoughtSignature) for later
tool_result resolution.

Split matching into two layers: when the incoming message carries any
tool_use ids, run id-based lookup first and return on the earliest hit.
Only fall back to full-name / normalized-name matching when the incoming
ids are absent or none of them resolve.

Add two regressions:

- shadow_replay_prefers_exact_id_match_over_normalized_name_collision
  Two shadow turns with colliding normalized names and two assistant
  messages whose ids cross the positional order; asserts each message
  replays the id-correct shadow turn (including thoughtSignature).

- shadow_replay_falls_back_to_name_when_ids_absent
  Shadow turn with no id and incoming tool_use with an empty id;
  asserts the name fallback still populates the replayed part.

src-tauri/src/proxy/forwarder.rs

@@ -9,7 +9,10 @@ use super::{
     failover_switch::FailoverSwitchManager,
     log_codes::fwd as log_fwd,
     provider_router::ProviderRouter,
-    providers::{get_adapter, AuthInfo, AuthStrategy, ProviderAdapter, ProviderType},
+    providers::{
+        gemini_shadow::GeminiShadowStore, get_adapter, AuthInfo, AuthStrategy, ProviderAdapter,
+        ProviderType,
+    },
     thinking_budget_rectifier::{rectify_thinking_budget, should_rectify_thinking_budget},
     thinking_rectifier::{
         normalize_thinking_type, rectify_anthropic_request, should_rectify_thinking_signature,
@@ -43,12 +46,15 @@ pub struct RequestForwarder {
     router: Arc<ProviderRouter>,
     status: Arc<RwLock<ProxyStatus>>,
     current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
+    gemini_shadow: Arc<GeminiShadowStore>,
     /// 故障转移切换管理器
     failover_manager: Arc<FailoverSwitchManager>,
     /// AppHandle，用于发射事件和更新托盘
     app_handle: Option<tauri::AppHandle>,
     /// 请求开始时的"当前供应商 ID"（用于判断是否需要同步 UI/托盘）
     current_provider_id_at_start: String,
+    /// 代理会话 ID（用于 Gemini Native shadow replay）
+    session_id: String,
     /// 整流器配置
     rectifier_config: RectifierConfig,
     /// 优化器配置
@@ -66,9 +72,11 @@ impl RequestForwarder {
         non_streaming_timeout: u64,
         status: Arc<RwLock<ProxyStatus>>,
         current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
+        gemini_shadow: Arc<GeminiShadowStore>,
         failover_manager: Arc<FailoverSwitchManager>,
         app_handle: Option<tauri::AppHandle>,
         current_provider_id_at_start: String,
+        session_id: String,
         _streaming_first_byte_timeout: u64,
         _streaming_idle_timeout: u64,
         rectifier_config: RectifierConfig,
@@ -79,9 +87,11 @@ impl RequestForwarder {
             router,
             status,
             current_providers,
+            gemini_shadow,
             failover_manager,
             app_handle,
             current_provider_id_at_start,
+            session_id,
             rectifier_config,
             optimizer_config,
             copilot_optimizer_config,
@@ -918,7 +928,7 @@ impl RequestForwarder {
                 let api_format = resolved_claude_api_format
                     .as_deref()
                     .unwrap_or_else(|| super::providers::get_claude_api_format(provider));
-                rewrite_claude_transform_endpoint(endpoint, api_format, is_copilot)
+                rewrite_claude_transform_endpoint(endpoint, api_format, is_copilot, &mapped_body)
             } else {
                 (
                     endpoint.to_string(),
@@ -928,7 +938,13 @@ impl RequestForwarder {
                 )
             };
 
-        let url = if is_full_url {
+        let url = if matches!(resolved_claude_api_format.as_deref(), Some("gemini_native")) {
+            super::gemini_url::resolve_gemini_native_url(
+                &base_url,
+                &effective_endpoint,
+                is_full_url,
+            )
+        } else if is_full_url {
             append_query_to_full_url(&base_url, passthrough_query.as_deref())
         } else {
             adapter.build_url(&base_url, &effective_endpoint)
@@ -944,6 +960,8 @@ impl RequestForwarder {
                     mapped_body,
                     provider,
                     api_format,
+                    Some(&self.session_id),
+                    Some(self.gemini_shadow.as_ref()),
                 )?
             } else {
                 adapter.transform_request(mapped_body, provider)?
@@ -1143,8 +1161,11 @@ impl RequestForwarder {
             .ok()
             .and_then(|u| u.authority().map(|a| a.to_string()));
 
+        let should_send_anthropic_headers = adapter.name() == "Claude"
+            && matches!(resolved_claude_api_format.as_deref(), Some("anthropic"));
+
         // 预计算 anthropic-beta 值（仅 Claude）
-        let anthropic_beta_value = if adapter.name() == "Claude" {
+        let anthropic_beta_value = if should_send_anthropic_headers {
             const CLAUDE_CODE_BETA: &str = "claude-code-20250219";
             Some(if let Some(beta) = headers.get("anthropic-beta") {
                 if let Ok(beta_str) = beta.to_str() {
@@ -1264,8 +1285,10 @@ impl RequestForwarder {
 
             // --- anthropic-version — 透传客户端值 ---
             if key_str.eq_ignore_ascii_case("anthropic-version") {
-                saw_anthropic_version = true;
-                ordered_headers.append(key.clone(), value.clone());
+                if should_send_anthropic_headers {
+                    saw_anthropic_version = true;
+                    ordered_headers.append(key.clone(), value.clone());
+                }
                 continue;
             }
 
@@ -1306,7 +1329,7 @@ impl RequestForwarder {
         }
 
         // anthropic-version：仅在缺失时补充默认值
-        if adapter.name() == "Claude" && !saw_anthropic_version {
+        if should_send_anthropic_headers && !saw_anthropic_version {
             ordered_headers.append(
                 "anthropic-version",
                 http::HeaderValue::from_static("2023-06-01"),
@@ -1650,6 +1673,7 @@ fn rewrite_claude_transform_endpoint(
     endpoint: &str,
     api_format: &str,
     is_copilot: bool,
+    body: &Value,
 ) -> (String, Option<String>) {
     let (path, query) = split_endpoint_and_query(endpoint);
     let passthrough_query = if is_claude_messages_path(path) {
@@ -1662,6 +1686,36 @@ fn rewrite_claude_transform_endpoint(
         return (endpoint.to_string(), passthrough_query);
     }
 
+    if api_format == "gemini_native" {
+        let model =
+            super::providers::transform_gemini::extract_gemini_model(body).unwrap_or("unknown");
+        // Accept both bare ids (`gemini-2.5-pro`) and the resource-name
+        // form (`models/gemini-2.5-pro`) that Gemini SDKs emit. See
+        // `normalize_gemini_model_id` for rationale.
+        let model = super::gemini_url::normalize_gemini_model_id(model);
+        let is_stream = body
+            .get("stream")
+            .and_then(|value| value.as_bool())
+            .unwrap_or(false);
+        let target_path = if is_stream {
+            format!("/v1beta/models/{model}:streamGenerateContent")
+        } else {
+            format!("/v1beta/models/{model}:generateContent")
+        };
+
+        let rewritten_query = merge_query_params(
+            passthrough_query.as_deref(),
+            if is_stream { Some("alt=sse") } else { None },
+        );
+
+        let rewritten = match rewritten_query.as_deref() {
+            Some(query) if !query.is_empty() => format!("{target_path}?{query}"),
+            _ => target_path,
+        };
+
+        return (rewritten, rewritten_query);
+    }
+
     let target_path = if is_copilot && api_format == "openai_responses" {
         "/v1/responses"
     } else if is_copilot {
@@ -1680,6 +1734,26 @@ fn rewrite_claude_transform_endpoint(
     (rewritten, passthrough_query)
 }
 
+fn merge_query_params(base_query: Option<&str>, extra_param: Option<&str>) -> Option<String> {
+    let mut params: Vec<String> = base_query
+        .into_iter()
+        .flat_map(|query| query.split('&'))
+        .filter(|pair| !pair.is_empty())
+        .filter(|pair| !pair.starts_with("alt="))
+        .map(ToString::to_string)
+        .collect();
+
+    if let Some(extra_param) = extra_param {
+        params.push(extra_param.to_string());
+    }
+
+    if params.is_empty() {
+        None
+    } else {
+        Some(params.join("&"))
+    }
+}
+
 fn append_query_to_full_url(base_url: &str, query: Option<&str>) -> String {
     match query {
         Some(query) if !query.is_empty() => {
@@ -1808,6 +1882,7 @@ mod tests {
             "/v1/messages?beta=true&foo=bar",
             "openai_chat",
             false,
+            &json!({ "model": "gpt-5.4" }),
         );
 
         assert_eq!(endpoint, "/v1/chat/completions?foo=bar");
@@ -1820,6 +1895,7 @@ mod tests {
             "/claude/v1/messages?beta=true&x-id=1",
             "openai_responses",
             false,
+            &json!({ "model": "gpt-5.4" }),
         );
 
         assert_eq!(endpoint, "/v1/responses?x-id=1");
@@ -1828,8 +1904,12 @@ mod tests {
 
     #[test]
     fn rewrite_claude_transform_endpoint_uses_copilot_path() {
-        let (endpoint, passthrough_query) =
-            rewrite_claude_transform_endpoint("/v1/messages?beta=true&x-id=1", "anthropic", true);
+        let (endpoint, passthrough_query) = rewrite_claude_transform_endpoint(
+            "/v1/messages?beta=true&x-id=1",
+            "anthropic",
+            true,
+            &json!({ "model": "claude-sonnet-4-6" }),
+        );
 
         assert_eq!(endpoint, "/chat/completions?x-id=1");
         assert_eq!(passthrough_query.as_deref(), Some("x-id=1"));
@@ -1841,12 +1921,60 @@ mod tests {
             "/v1/messages?beta=true&x-id=1",
             "openai_responses",
             true,
+            &json!({ "model": "gpt-5.4" }),
         );
 
         assert_eq!(endpoint, "/v1/responses?x-id=1");
         assert_eq!(passthrough_query.as_deref(), Some("x-id=1"));
     }
 
+    #[test]
+    fn rewrite_claude_transform_endpoint_maps_gemini_generate_content() {
+        let (endpoint, passthrough_query) = rewrite_claude_transform_endpoint(
+            "/v1/messages?beta=true&x-id=1",
+            "gemini_native",
+            false,
+            &json!({ "model": "gemini-2.5-pro" }),
+        );
+
+        assert_eq!(
+            endpoint,
+            "/v1beta/models/gemini-2.5-pro:generateContent?x-id=1"
+        );
+        assert_eq!(passthrough_query.as_deref(), Some("x-id=1"));
+    }
+
+    /// Regression: body.model arriving as the resource-name form
+    /// `models/gemini-2.5-pro` must not produce a doubled
+    /// `/v1beta/models/models/...` path.
+    #[test]
+    fn rewrite_claude_transform_endpoint_strips_gemini_model_resource_prefix() {
+        let (endpoint, _) = rewrite_claude_transform_endpoint(
+            "/v1/messages",
+            "gemini_native",
+            false,
+            &json!({ "model": "models/gemini-2.5-pro" }),
+        );
+
+        assert_eq!(endpoint, "/v1beta/models/gemini-2.5-pro:generateContent");
+    }
+
+    #[test]
+    fn rewrite_claude_transform_endpoint_maps_gemini_streaming() {
+        let (endpoint, passthrough_query) = rewrite_claude_transform_endpoint(
+            "/v1/messages?beta=true",
+            "gemini_native",
+            false,
+            &json!({ "model": "gemini-2.5-flash", "stream": true }),
+        );
+
+        assert_eq!(
+            endpoint,
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+        assert_eq!(passthrough_query.as_deref(), Some("alt=sse"));
+    }
+
     #[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"));
@@ -1854,6 +1982,43 @@ mod tests {
         assert_eq!(url, "https://relay.example/api?foo=bar&x-id=1");
     }
 
+    #[test]
+    fn build_gemini_native_url_uses_origin_when_base_ends_with_v1beta() {
+        let url = crate::proxy::gemini_url::build_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta",
+            "/v1beta/models/gemini-2.5-pro:generateContent",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent"
+        );
+    }
+
+    #[test]
+    fn build_gemini_native_url_uses_origin_when_base_already_contains_models_prefix() {
+        let url = crate::proxy::gemini_url::build_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta/models",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn resolve_gemini_native_url_keeps_opaque_full_url_as_is() {
+        let url = crate::proxy::gemini_url::resolve_gemini_native_url(
+            "https://relay.example/custom/generate-content",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/generate-content?alt=sse");
+    }
+
     #[test]
     fn force_identity_for_stream_flag_requests() {
         let headers = HeaderMap::new();

src-tauri/src/proxy/gemini_url.rs

@@ -0,0 +1,665 @@
+//! Gemini Native URL helpers.
+//!
+//! Normalizes legacy Gemini/OpenAI-compatible base URLs into the canonical
+//! Gemini Native `models/*:generateContent` endpoints.
+
+/// Normalize a Gemini model identifier to its bare form, stripping an
+/// optional leading `models/` (and any leading `/`) so that the value can
+/// be safely interpolated into a URL template like
+/// `/v1beta/models/{model}:generateContent`.
+///
+/// Gemini SDKs and documentation commonly surface model ids as
+/// `models/gemini-2.5-pro` (the resource-name form). Passing that value
+/// through to the format string would otherwise yield a doubled prefix
+/// like `/v1beta/models/models/gemini-2.5-pro:generateContent`, which is
+/// rejected by the upstream API and turns any health check or live
+/// request into a false negative.
+pub fn normalize_gemini_model_id(model: &str) -> &str {
+    let trimmed = model.strip_prefix('/').unwrap_or(model);
+    trimmed.strip_prefix("models/").unwrap_or(trimmed)
+}
+
+pub fn resolve_gemini_native_url(base_url: &str, endpoint: &str, is_full_url: bool) -> String {
+    if !is_full_url || should_normalize_gemini_full_url(base_url) {
+        return build_gemini_native_url(base_url, endpoint);
+    }
+
+    let base_url = base_url
+        .split_once('#')
+        .map_or(base_url, |(base, _)| base)
+        .trim_end_matches('/');
+    let (base_without_query, base_query) = split_query(base_url);
+    let (_, endpoint_query) = split_query(endpoint);
+
+    let mut url = base_without_query.to_string();
+    if let Some(query) = merge_queries(base_query, endpoint_query) {
+        url.push('?');
+        url.push_str(&query);
+    }
+
+    url
+}
+
+pub fn build_gemini_native_url(base_url: &str, endpoint: &str) -> String {
+    let base_url = base_url
+        .split_once('#')
+        .map_or(base_url, |(base, _)| base)
+        .trim_end_matches('/');
+    let (base_without_query, base_query) = split_query(base_url);
+    let (endpoint_without_query, endpoint_query) = split_query(endpoint);
+
+    let endpoint_path = format!("/{}", endpoint_without_query.trim_start_matches('/'));
+    let (origin, raw_path) = split_origin_and_path(base_without_query);
+    let prefix_path = normalize_gemini_base_path(raw_path);
+
+    let mut url = if prefix_path.is_empty() {
+        format!("{origin}{endpoint_path}")
+    } else {
+        format!("{origin}{prefix_path}{endpoint_path}")
+    };
+
+    if let Some(query) = merge_queries(base_query, endpoint_query) {
+        url.push('?');
+        url.push_str(&query);
+    }
+
+    url
+}
+
+fn should_normalize_gemini_full_url(base_url: &str) -> bool {
+    let base_url = base_url
+        .split_once('#')
+        .map_or(base_url, |(base, _)| base)
+        .trim_end_matches('/');
+    let (base_without_query, _) = split_query(base_url);
+    let (origin, path) = split_origin_and_path(base_without_query);
+
+    if path.is_empty() || path == "/" {
+        return true;
+    }
+
+    let path = path.trim_end_matches('/');
+    let on_google_host = is_google_gemini_host(extract_host(origin));
+
+    // Unconditional layer: only paths whose grammar is *intrinsically*
+    // Gemini-specific — the `/models/...:generateContent` method-call
+    // shape and the deep OpenAI-compat endpoints (`/openai/chat/completions`,
+    // `/openai/responses`) that are implausibly used as a relay's fixed
+    // terminal path — get rewritten regardless of host.
+    if matches_structured_gemini_models_path(path)
+        || path.ends_with("/v1beta/openai/chat/completions")
+        || path.ends_with("/v1beta/openai/responses")
+        || path.ends_with("/openai/chat/completions")
+        || path.ends_with("/openai/responses")
+        || path.ends_with("/v1/openai/chat/completions")
+        || path.ends_with("/v1/openai/responses")
+    {
+        return true;
+    }
+
+    // All other version / resource-root suffixes — `/v1beta`, `/v1`,
+    // `/models`, `/openai`, and variants — could legitimately be an
+    // opaque relay's fixed endpoint (`https://relay.example/custom/v1beta`
+    // is a real deployment shape, even if uncommon outside Google's
+    // ecosystem). Only rewrite when the host itself is Google's Gemini
+    // or Vertex AI endpoint.
+    if on_google_host
+        && (path.ends_with("/v1beta")
+            || path.ends_with("/v1beta/models")
+            || path.ends_with("/v1beta/openai")
+            || path.ends_with("/v1")
+            || path.ends_with("/v1/models")
+            || path.ends_with("/models")
+            || path.ends_with("/v1/openai")
+            || path.ends_with("/openai"))
+    {
+        return true;
+    }
+
+    false
+}
+
+/// Extract the host portion of an origin like `https://host:port` or
+/// `https://host`. Returns an empty string if no host can be found (e.g.
+/// bare `http://`).
+fn extract_host(origin: &str) -> &str {
+    let after_scheme = origin.split_once("://").map_or(origin, |(_, rest)| rest);
+    // authority may carry credentials (`user:pass@host`) and a port
+    // (`host:port`). Strip userinfo first, then port.
+    let without_userinfo = after_scheme
+        .rsplit_once('@')
+        .map_or(after_scheme, |(_, h)| h);
+    let without_port = without_userinfo
+        .split_once(':')
+        .map_or(without_userinfo, |(h, _)| h);
+    // Strip trailing `/` defensively (split_origin_and_path already handled
+    // it, but this helper may be reused elsewhere).
+    without_port.trim_end_matches('/')
+}
+
+/// Returns true when `host` is one of Google's Gemini / Vertex AI endpoints.
+/// Case-insensitive. Requires exact match or a real `-aiplatform.googleapis.com`
+/// subdomain suffix — not a substring match, so lookalikes like
+/// `aiplatform.example.com` are rejected.
+fn is_google_gemini_host(host: &str) -> bool {
+    if host.is_empty() {
+        return false;
+    }
+    let host_lower = host.to_ascii_lowercase();
+    host_lower == "generativelanguage.googleapis.com"
+        || host_lower == "aiplatform.googleapis.com"
+        || host_lower.ends_with("-aiplatform.googleapis.com")
+}
+
+fn split_query(input: &str) -> (&str, Option<&str>) {
+    input
+        .split_once('?')
+        .map_or((input, None), |(path, query)| (path, Some(query)))
+}
+
+fn split_origin_and_path(base_url: &str) -> (&str, &str) {
+    let Some(scheme_sep) = base_url.find("://") else {
+        return (base_url, "");
+    };
+    let authority_start = scheme_sep + 3;
+    let Some(path_start_rel) = base_url[authority_start..].find('/') else {
+        return (base_url, "");
+    };
+    let path_start = authority_start + path_start_rel;
+    (&base_url[..path_start], &base_url[path_start..])
+}
+
+fn normalize_gemini_base_path(path: &str) -> String {
+    let path = path.trim_end_matches('/');
+    if path.is_empty() || path == "/" {
+        return String::new();
+    }
+
+    for marker in ["/v1beta/models/", "/v1/models/", "/models/"] {
+        if let Some(index) = path.find(marker) {
+            return normalize_prefix(&path[..index]);
+        }
+    }
+
+    for suffix in [
+        "/v1beta/openai/chat/completions",
+        "/v1/openai/chat/completions",
+        "/openai/chat/completions",
+        "/v1beta/openai/responses",
+        "/v1/openai/responses",
+        "/openai/responses",
+        "/v1beta/openai",
+        "/v1/openai",
+        "/openai",
+        "/v1beta/models",
+        "/v1/models",
+        "/models",
+        "/v1beta",
+        "/v1",
+    ] {
+        if path == suffix {
+            return String::new();
+        }
+        if let Some(prefix) = path.strip_suffix(suffix) {
+            return normalize_prefix(prefix);
+        }
+    }
+
+    path.to_string()
+}
+
+fn normalize_prefix(prefix: &str) -> String {
+    let prefix = prefix.trim_end_matches('/');
+    if prefix.is_empty() || prefix == "/" {
+        String::new()
+    } else {
+        prefix.to_string()
+    }
+}
+
+/// Returns true when `path` contains a `/models/` segment followed by a
+/// canonical Gemini method call (`*:generateContent` or
+/// `*:streamGenerateContent`). The `/models/` segment alone is not enough:
+/// opaque relay routes such as `/v1/models/invoke` or `/custom/models/foo`
+/// also contain `/models/` but are not Gemini-structured and must not be
+/// rewritten.
+fn matches_structured_gemini_models_path(path: &str) -> bool {
+    let mut cursor = path;
+    while let Some(idx) = cursor.find("/models/") {
+        let after = &cursor[idx + "/models/".len()..];
+        if after.contains(":generateContent") || after.contains(":streamGenerateContent") {
+            return true;
+        }
+        // Advance past this `/models/` occurrence so a later Gemini-style
+        // segment in the same path (unusual but cheap to handle) can still
+        // match.
+        cursor = &cursor[idx + "/models/".len()..];
+    }
+    false
+}
+
+fn merge_queries(base_query: Option<&str>, endpoint_query: Option<&str>) -> Option<String> {
+    let parts: Vec<&str> = [base_query, endpoint_query]
+        .into_iter()
+        .flatten()
+        .flat_map(|query| query.split('&'))
+        .filter(|part| !part.is_empty())
+        .collect();
+
+    if parts.is_empty() {
+        None
+    } else {
+        Some(parts.join("&"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{build_gemini_native_url, normalize_gemini_model_id, resolve_gemini_native_url};
+
+    #[test]
+    fn strips_version_root_for_official_base() {
+        let url = build_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta",
+            "/v1beta/models/gemini-2.5-pro:generateContent",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent"
+        );
+    }
+
+    #[test]
+    fn strips_openai_compat_path_for_official_base() {
+        let url = build_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+            "/v1beta/models/gemini-2.5-pro:generateContent",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent"
+        );
+    }
+
+    #[test]
+    fn preserves_custom_proxy_prefix_while_stripping_openai_suffix() {
+        let url = build_gemini_native_url(
+            "https://proxy.example.com/google/v1beta/openai/chat/completions",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+        );
+
+        assert_eq!(
+            url,
+            "https://proxy.example.com/google/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn strips_model_method_path_from_full_url_base() {
+        let url = build_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn resolves_structured_full_url_by_normalizing_to_requested_method() {
+        let url = resolve_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn resolves_opaque_full_url_without_appending_gemini_models_path() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/generate-content",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/generate-content?alt=sse");
+    }
+
+    #[test]
+    fn preserves_opaque_full_url_containing_models_segment() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/models/invoke",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/models/invoke?alt=sse");
+    }
+
+    /// Regression: a relay whose fixed path starts with `/v1/models/` is an
+    /// opaque route, not a Gemini-structured endpoint. The previous
+    /// heuristic matched any `contains("/v1/models/")` and rewrote it to
+    /// `/v1beta/models/{model}:generateContent`, dropping the relay's own
+    /// route component (`/invoke`) and sending traffic to the wrong place.
+    #[test]
+    fn preserves_opaque_full_url_with_v1_models_prefix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/v1/models/invoke",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/v1/models/invoke?alt=sse");
+    }
+
+    /// Same regression, `/v1beta/models/` variant — relays may use Google's
+    /// path layout defensively for routing while still being opaque.
+    #[test]
+    fn preserves_opaque_full_url_with_v1beta_models_prefix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/v1beta/models/route",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/v1beta/models/route?alt=sse");
+    }
+
+    /// Counter-case: a full URL that *does* carry a genuine Gemini method
+    /// segment (`:generateContent`) under `/v1/models/` should still be
+    /// recognized as structured and normalized to the requested model.
+    #[test]
+    fn normalizes_structured_v1_models_path_with_method_segment() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/v1/models/gemini-2.5-pro:generateContent",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://relay.example/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // Google-host whitelist tests (generic REST suffix handling)
+    //
+    // Generic REST conventions like `/v1`, `/models`, `/openai` legitimately
+    // appear on opaque relays. `should_normalize_gemini_full_url` only
+    // treats these as structured Gemini endpoints when the host itself is
+    // Google's Gemini or Vertex AI endpoint.
+    // ------------------------------------------------------------------
+
+    /// Regression: a relay whose fixed path ends with `/v1` (a ubiquitous
+    /// REST convention) used to be rewritten to
+    /// `/v1beta/models/{model}:generateContent`, dropping the relay's own
+    /// `/v1` endpoint.
+    #[test]
+    fn preserves_opaque_full_url_with_v1_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/v1?alt=sse");
+    }
+
+    /// Companion case: bare `/models` suffix on a non-Google host is a
+    /// generic REST path, not a Gemini-structured endpoint.
+    #[test]
+    fn preserves_opaque_full_url_with_models_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/models",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/models?alt=sse");
+    }
+
+    /// Companion case: `/v1/models` — same ambiguity as `/models`, with the
+    /// version prefix. Must stay as-is on non-Google hosts.
+    #[test]
+    fn preserves_opaque_full_url_with_v1_models_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1/models",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/v1/models?alt=sse");
+    }
+
+    /// Companion case: a relay that exposes an `/openai` compatibility
+    /// surface without the deep `/openai/chat/completions` path. Must stay
+    /// as-is on non-Google hosts.
+    #[test]
+    fn preserves_opaque_full_url_with_openai_suffix_on_non_google_host() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/openai",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/openai?alt=sse");
+    }
+
+    /// Counter-case: `/v1` on the official Gemini host must still be
+    /// normalized to the full `/v1beta/models/...` endpoint — users who
+    /// paste `https://generativelanguage.googleapis.com/v1` as their base
+    /// URL expect the proxy to resolve the method path.
+    #[test]
+    fn normalizes_google_host_with_v1_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    /// Counter-case: `/models` on the official Gemini host is recognized
+    /// and normalized.
+    #[test]
+    fn normalizes_google_host_with_models_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://generativelanguage.googleapis.com/models",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    /// Counter-case: Vertex AI regional endpoints live under
+    /// `*-aiplatform.googleapis.com`. Those should also be treated as
+    /// Google-host for the whitelist.
+    #[test]
+    fn normalizes_vertex_aiplatform_host_with_v1_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://us-central1-aiplatform.googleapis.com/v1",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://us-central1-aiplatform.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    /// Safety: the Google-host whitelist must do an exact/suffix match, not
+    /// a `contains`. A lookalike host like `aiplatform.example.com` must
+    /// NOT be treated as Google.
+    #[test]
+    fn preserves_non_google_aiplatform_lookalike_host() {
+        let url = resolve_gemini_native_url(
+            "https://aiplatform.example.com/v1",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://aiplatform.example.com/v1?alt=sse");
+    }
+
+    /// Regression: `/v1beta` by itself is Google-conventional but not
+    /// literally impossible on other hosts. An opaque relay fronting a
+    /// non-Gemini service at `https://relay.example/custom/v1beta` would
+    /// be silently rewritten if `/v1beta` were classified as unconditional
+    /// structured Gemini. Require the Google-host whitelist instead.
+    #[test]
+    fn preserves_opaque_full_url_with_bare_v1beta_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1beta",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/v1beta?alt=sse");
+    }
+
+    /// Companion case: `/v1beta/models` (no method segment) on a non-Google
+    /// host stays as-is too.
+    #[test]
+    fn preserves_opaque_full_url_with_v1beta_models_suffix_no_method() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1beta/models",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(url, "https://relay.example/custom/v1beta/models?alt=sse");
+    }
+
+    /// Counter-case: `/v1beta` on the official Gemini host must still
+    /// normalize — this is the canonical base URL shape users paste from
+    /// AI Studio documentation.
+    #[test]
+    fn normalizes_google_host_with_v1beta_suffix() {
+        let url = resolve_gemini_native_url(
+            "https://generativelanguage.googleapis.com/v1beta",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            true,
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    /// Regression guard: in non-full-URL mode, a versioned third-party
+    /// relay base must have its `/v1beta` suffix **stripped** so the
+    /// appended standard endpoint (`/v1beta/models/{model}:method`) does
+    /// not produce a doubled `/v1beta/v1beta/models/...` path. Non-full
+    /// mode's contract is "base URL + cc-switch appends the canonical
+    /// Gemini endpoint" — a user who wants a relay's custom namespace
+    /// (e.g. `/v1/models/...`) must use full-URL mode instead.
+    ///
+    /// This test pins the intentional asymmetry with
+    /// `preserves_opaque_full_url_with_bare_v1beta_suffix` (full-URL
+    /// preserves, non-full strips) so nobody "fixes" one side into
+    /// breaking the other.
+    #[test]
+    fn strips_versioned_relay_base_suffix_in_non_full_url_mode() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1beta",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            false,
+        );
+
+        assert_eq!(
+            url,
+            "https://relay.example/custom/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    /// Companion case: `/v1` base suffix also stripped in non-full-URL
+    /// mode regardless of host.
+    #[test]
+    fn strips_v1_relay_base_suffix_in_non_full_url_mode() {
+        let url = resolve_gemini_native_url(
+            "https://relay.example/custom/v1",
+            "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
+            false,
+        );
+
+        assert_eq!(
+            url,
+            "https://relay.example/custom/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // Model ID normalization tests.
+    //
+    // Gemini SDKs and documentation commonly surface model identifiers as
+    // `models/gemini-2.5-pro` (resource-name form). If that value flows
+    // straight into our URL builder, the format string
+    // `/v1beta/models/{model}:generateContent` produces a doubled prefix
+    // `/v1beta/models/models/gemini-2.5-pro:generateContent`, which is
+    // rejected upstream. `normalize_gemini_model_id` is the single source
+    // of truth callers should run the model through first.
+    // ------------------------------------------------------------------
+
+    #[test]
+    fn normalize_model_id_strips_models_prefix() {
+        assert_eq!(
+            normalize_gemini_model_id("models/gemini-2.5-pro"),
+            "gemini-2.5-pro"
+        );
+    }
+
+    #[test]
+    fn normalize_model_id_leaves_bare_id_unchanged() {
+        assert_eq!(
+            normalize_gemini_model_id("gemini-2.5-pro"),
+            "gemini-2.5-pro"
+        );
+    }
+
+    #[test]
+    fn normalize_model_id_preserves_nested_slashes_after_prefix() {
+        // e.g. tuned model resource like `models/gemini-2.5-pro/tunedModels/xxx`
+        // — the caller asked for a specific tuned model resource, keep its
+        // identity intact after stripping only the single leading prefix.
+        assert_eq!(
+            normalize_gemini_model_id("models/tunedModels/my-tuned"),
+            "tunedModels/my-tuned"
+        );
+    }
+
+    #[test]
+    fn normalize_model_id_tolerates_leading_slash() {
+        assert_eq!(
+            normalize_gemini_model_id("/models/gemini-2.5-flash"),
+            "gemini-2.5-flash"
+        );
+    }
+
+    #[test]
+    fn normalize_model_id_preserves_empty_input() {
+        // Edge: caller has no model at all. Pass through so the URL error
+        // surfaces at the request layer rather than producing a misleading
+        // empty segment here.
+        assert_eq!(normalize_gemini_model_id(""), "");
+    }
+}

src-tauri/src/proxy/handler_context.rs

@@ -218,9 +218,11 @@ impl RequestContext {
             non_streaming_timeout,
             state.status.clone(),
             state.current_providers.clone(),
+            state.gemini_shadow.clone(),
             state.failover_manager.clone(),
             state.app_handle.clone(),
             self.current_provider_id.clone(),
+            self.session_id.clone(),
             first_byte_timeout,
             idle_timeout,
             self.rectifier_config.clone(),

src-tauri/src/proxy/handlers.rs

@@ -15,8 +15,9 @@ use super::{
     handler_context::RequestContext,
     providers::{
         get_adapter, get_claude_api_format, streaming::create_anthropic_sse_stream,
+        streaming_gemini::create_anthropic_sse_stream_from_gemini,
         streaming_responses::create_anthropic_sse_stream_from_responses, transform,
-        transform_responses,
+        transform_gemini, transform_responses,
     },
     response_processor::{
         create_logged_passthrough_stream, process_response, read_decoded_body,
@@ -145,11 +146,13 @@ async fn handle_claude_transform(
     response: super::hyper_client::ProxyResponse,
     ctx: &RequestContext,
     state: &ProxyState,
-    _original_body: &Value,
+    original_body: &Value,
     is_stream: bool,
     api_format: &str,
 ) -> Result<axum::response::Response, ProxyError> {
     let status = response.status();
+    let tool_schema_hints = transform_gemini::extract_anthropic_tool_schema_hints(original_body);
+    let tool_schema_hints = (!tool_schema_hints.is_empty()).then_some(tool_schema_hints);
 
     if is_stream {
         // 根据 api_format 选择流式转换器
@@ -158,6 +161,14 @@ async fn handle_claude_transform(
             dyn futures::Stream<Item = Result<Bytes, std::io::Error>> + Send + Unpin,
         > = if api_format == "openai_responses" {
             Box::new(Box::pin(create_anthropic_sse_stream_from_responses(stream)))
+        } else if api_format == "gemini_native" {
+            Box::new(Box::pin(create_anthropic_sse_stream_from_gemini(
+                stream,
+                Some(state.gemini_shadow.clone()),
+                Some(ctx.provider.id.clone()),
+                Some(ctx.session_id.clone()),
+                tool_schema_hints.clone(),
+            )))
         } else {
             Box::new(Box::pin(create_anthropic_sse_stream(stream)))
         };
@@ -242,6 +253,14 @@ async fn handle_claude_transform(
     // 根据 api_format 选择非流式转换器
     let anthropic_response = if api_format == "openai_responses" {
         transform_responses::responses_to_anthropic(upstream_response)
+    } else if api_format == "gemini_native" {
+        transform_gemini::gemini_to_anthropic_with_shadow_and_hints(
+            upstream_response,
+            Some(state.gemini_shadow.as_ref()),
+            Some(&ctx.provider.id),
+            Some(&ctx.session_id),
+            tool_schema_hints.as_ref(),
+        )
     } else {
         transform::openai_to_anthropic(upstream_response)
     }

src-tauri/src/proxy/mod.rs

@@ -10,6 +10,7 @@ pub mod error;
 pub mod error_mapper;
 pub(crate) mod failover_switch;
 mod forwarder;
+pub mod gemini_url;
 pub mod handler_config;
 pub mod handler_context;
 mod handlers;

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

@@ -6,6 +6,7 @@
 //! - **anthropic** (默认): Anthropic Messages API 格式，直接透传
 //! - **openai_chat**: OpenAI Chat Completions 格式，需要 Anthropic ↔ OpenAI 转换
 //! - **openai_responses**: OpenAI Responses API 格式，需要 Anthropic ↔ Responses 转换
+//! - **gemini_native**: Google Gemini Native generateContent 格式，需要 Anthropic ↔ Gemini 转换
 //!
 //! ## 认证模式
 //! - **Claude**: Anthropic 官方 API (x-api-key + anthropic-version)
@@ -35,6 +36,7 @@ pub fn get_claude_api_format(provider: &Provider) -> &'static str {
             return match api_format {
                 "openai_chat" => "openai_chat",
                 "openai_responses" => "openai_responses",
+                "gemini_native" => "gemini_native",
                 _ => "anthropic",
             };
         }
@@ -49,6 +51,7 @@ pub fn get_claude_api_format(provider: &Provider) -> &'static str {
         return match api_format {
             "openai_chat" => "openai_chat",
             "openai_responses" => "openai_responses",
+            "gemini_native" => "gemini_native",
             _ => "anthropic",
         };
     }
@@ -73,13 +76,18 @@ pub fn get_claude_api_format(provider: &Provider) -> &'static str {
 }
 
 pub fn claude_api_format_needs_transform(api_format: &str) -> bool {
-    matches!(api_format, "openai_chat" | "openai_responses")
+    matches!(
+        api_format,
+        "openai_chat" | "openai_responses" | "gemini_native"
+    )
 }
 
 pub fn transform_claude_request_for_api_format(
     body: serde_json::Value,
     provider: &Provider,
     api_format: &str,
+    session_id: Option<&str>,
+    shadow_store: Option<&super::gemini_shadow::GeminiShadowStore>,
 ) -> Result<serde_json::Value, ProxyError> {
     // Copilot 场景：优先从 metadata.user_id 提取 session ID 作为 cache key
     // 格式: "uuid_sessionId" → 提取 "_" 后面的部分作为 session 标识
@@ -138,7 +146,24 @@ pub fn transform_claude_request_for_api_format(
                 is_codex_oauth,
             )
         }
-        "openai_chat" => super::transform::anthropic_to_openai(body),
+        "openai_chat" => {
+            let mut result = super::transform::anthropic_to_openai(body)?;
+            // Inject prompt_cache_key only if explicitly configured in meta
+            if let Some(key) = provider
+                .meta
+                .as_ref()
+                .and_then(|m| m.prompt_cache_key.as_deref())
+            {
+                result["prompt_cache_key"] = serde_json::json!(key);
+            }
+            Ok(result)
+        }
+        "gemini_native" => super::transform_gemini::anthropic_to_gemini_with_shadow(
+            body,
+            shadow_store,
+            Some(&provider.id),
+            session_id,
+        ),
         _ => Ok(body),
     }
 }
@@ -160,6 +185,16 @@ impl ClaudeAdapter {
     /// - ClaudeAuth: auth_mode 为 bearer_only
     /// - Claude: 默认 Anthropic 官方
     pub fn provider_type(&self, provider: &Provider) -> ProviderType {
+        // 检测 Gemini Native 格式
+        if self.get_api_format(provider) == "gemini_native" {
+            return match self.extract_key(provider) {
+                Some(key) if key.starts_with("ya29.") || key.starts_with('{') => {
+                    ProviderType::GeminiCli
+                }
+                _ => ProviderType::Gemini,
+            };
+        }
+
         // 检测 Codex OAuth (ChatGPT Plus/Pro)
         if self.is_codex_oauth(provider) {
             return ProviderType::CodexOAuth;
@@ -262,6 +297,7 @@ impl ClaudeAdapter {
             if let Some(key) = env
                 .get("ANTHROPIC_AUTH_TOKEN")
                 .and_then(|v| v.as_str())
+                .map(str::trim)
                 .filter(|s| !s.is_empty())
             {
                 log::debug!("[Claude] 使用 ANTHROPIC_AUTH_TOKEN");
@@ -270,6 +306,7 @@ impl ClaudeAdapter {
             if let Some(key) = env
                 .get("ANTHROPIC_API_KEY")
                 .and_then(|v| v.as_str())
+                .map(str::trim)
                 .filter(|s| !s.is_empty())
             {
                 log::debug!("[Claude] 使用 ANTHROPIC_API_KEY");
@@ -279,6 +316,7 @@ impl ClaudeAdapter {
             if let Some(key) = env
                 .get("OPENROUTER_API_KEY")
                 .and_then(|v| v.as_str())
+                .map(str::trim)
                 .filter(|s| !s.is_empty())
             {
                 log::debug!("[Claude] 使用 OPENROUTER_API_KEY");
@@ -288,6 +326,7 @@ impl ClaudeAdapter {
             if let Some(key) = env
                 .get("OPENAI_API_KEY")
                 .and_then(|v| v.as_str())
+                .map(str::trim)
                 .filter(|s| !s.is_empty())
             {
                 log::debug!("[Claude] 使用 OPENAI_API_KEY");
@@ -301,6 +340,7 @@ impl ClaudeAdapter {
             .get("apiKey")
             .or_else(|| provider.settings_config.get("api_key"))
             .and_then(|v| v.as_str())
+            .map(str::trim)
             .filter(|s| !s.is_empty())
         {
             log::debug!("[Claude] 使用 apiKey/api_key");
@@ -388,14 +428,43 @@ impl ProviderAdapter for ClaudeAdapter {
             ));
         }
 
-        let strategy = match provider_type {
-            ProviderType::OpenRouter => AuthStrategy::Bearer,
-            ProviderType::ClaudeAuth => AuthStrategy::ClaudeAuth,
-            _ => AuthStrategy::Anthropic,
-        };
+        let key = self.extract_key(provider)?;
 
-        self.extract_key(provider)
-            .map(|key| AuthInfo::new(key, strategy))
+        match provider_type {
+            ProviderType::GeminiCli => {
+                // Parse stored OAuth JSON and only attach access_token when
+                // it's actually usable. `parse_oauth_credentials` accepts
+                // refresh-token-only JSON (which is legitimate before the
+                // first refresh) and also surfaces `{"access_token": "", ...}`
+                // for expired credentials. In both cases we would otherwise
+                // send `Authorization: Bearer ` to upstream and get a 401.
+                //
+                // CC Switch does not currently exchange the refresh_token for
+                // a fresh access_token. Until that path exists, degrade to
+                // plain GoogleOAuth strategy (which still sends the raw key
+                // as a fallback) and log loudly so users know to refresh
+                // their `~/.gemini/oauth_creds.json`.
+                match super::gemini::GeminiAdapter::new().parse_oauth_credentials(&key) {
+                    Some(creds) if !creds.access_token.is_empty() => {
+                        Some(AuthInfo::with_access_token(key, creds.access_token))
+                    }
+                    Some(_) => {
+                        log::warn!(
+                            "[Gemini OAuth] access_token missing or empty for provider `{}`; \
+                             bearer auth will likely fail with 401. Refresh \
+                             ~/.gemini/oauth_creds.json via the gemini CLI to obtain a new token.",
+                            provider.id
+                        );
+                        Some(AuthInfo::new(key, AuthStrategy::GoogleOAuth))
+                    }
+                    None => Some(AuthInfo::new(key, AuthStrategy::GoogleOAuth)),
+                }
+            }
+            ProviderType::Gemini => Some(AuthInfo::new(key, AuthStrategy::Google)),
+            ProviderType::OpenRouter => Some(AuthInfo::new(key, AuthStrategy::Bearer)),
+            ProviderType::ClaudeAuth => Some(AuthInfo::new(key, AuthStrategy::ClaudeAuth)),
+            _ => Some(AuthInfo::new(key, AuthStrategy::Anthropic)),
+        }
     }
 
     fn build_url(&self, base_url: &str, endpoint: &str) -> String {
@@ -437,6 +506,23 @@ impl ProviderAdapter for ClaudeAdapter {
                     HeaderValue::from_str(&bearer).unwrap(),
                 )]
             }
+            AuthStrategy::Google => vec![(
+                HeaderName::from_static("x-goog-api-key"),
+                HeaderValue::from_str(&auth.api_key).unwrap(),
+            )],
+            AuthStrategy::GoogleOAuth => {
+                let token = auth.access_token.as_ref().unwrap_or(&auth.api_key);
+                vec![
+                    (
+                        HeaderName::from_static("authorization"),
+                        HeaderValue::from_str(&format!("Bearer {token}")).unwrap(),
+                    ),
+                    (
+                        HeaderName::from_static("x-goog-api-client"),
+                        HeaderValue::from_static("GeminiCLI/1.0"),
+                    ),
+                ]
+            }
             AuthStrategy::CodexOAuth => {
                 // 注意：bearer token 由 forwarder 动态注入到 auth.api_key
                 // ChatGPT-Account-Id 由 forwarder 注入额外 header
@@ -507,7 +593,6 @@ impl ProviderAdapter for ClaudeAdapter {
                     ),
                 ]
             }
-            _ => vec![],
         }
     }
 
@@ -528,7 +613,7 @@ impl ProviderAdapter for ClaudeAdapter {
         // - "openai_responses": 需要 Anthropic ↔ OpenAI Responses API 格式转换
         matches!(
             self.get_api_format(provider),
-            "openai_chat" | "openai_responses"
+            "openai_chat" | "openai_responses" | "gemini_native"
         )
     }
 
@@ -537,7 +622,13 @@ impl ProviderAdapter for ClaudeAdapter {
         body: serde_json::Value,
         provider: &Provider,
     ) -> Result<serde_json::Value, ProxyError> {
-        transform_claude_request_for_api_format(body, provider, self.get_api_format(provider))
+        transform_claude_request_for_api_format(
+            body,
+            provider,
+            self.get_api_format(provider),
+            None,
+            None,
+        )
     }
 
     fn transform_response(&self, body: serde_json::Value) -> Result<serde_json::Value, ProxyError> {
@@ -546,7 +637,9 @@ impl ProviderAdapter for ClaudeAdapter {
         // config, so we can't check api_format here. Instead we rely on the fact that
         // Responses API always returns "output" while Chat Completions returns "choices".
         // This is safe because the two formats are structurally disjoint.
-        if body.get("output").is_some() {
+        if body.get("candidates").is_some() || body.get("promptFeedback").is_some() {
+            super::transform_gemini::gemini_to_anthropic(body)
+        } else if body.get("output").is_some() {
             super::transform_responses::responses_to_anthropic(body)
         } else {
             super::transform::openai_to_anthropic(body)
@@ -684,6 +777,146 @@ mod tests {
         assert_eq!(auth.strategy, AuthStrategy::ClaudeAuth);
     }
 
+    /// Regression: a Gemini OAuth credential JSON that carries only a
+    /// refresh_token (no active access_token) must not be surfaced as an
+    /// `AuthInfo` whose bearer would be empty. Without the guard, downstream
+    /// header injection produces `Authorization: Bearer ` and a deterministic
+    /// 401 from upstream.
+    #[test]
+    fn test_extract_auth_gemini_cli_refresh_only_json_does_not_expose_empty_bearer() {
+        let adapter = ClaudeAdapter::new();
+        let refresh_only_json =
+            r#"{"refresh_token":"rt-abc","client_id":"cid","client_secret":"cs"}"#;
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": refresh_only_json
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        // access_token must not be surfaced as `Some("")` — the OAuth header
+        // builder uses `access_token.as_ref().unwrap_or(&api_key)`, so a
+        // `Some("")` would win over the raw key and emit `Bearer `.
+        assert!(
+            auth.access_token.as_deref().is_none_or(|t| !t.is_empty()),
+            "empty access_token leaked into AuthInfo"
+        );
+        assert_eq!(auth.strategy, AuthStrategy::GoogleOAuth);
+    }
+
+    /// Companion case: a JSON credential with an empty-string `access_token`
+    /// field (the shape an expired credential can take after partial writes)
+    /// must degrade the same way.
+    #[test]
+    fn test_extract_auth_gemini_cli_empty_access_token_degrades_to_raw_key() {
+        let adapter = ClaudeAdapter::new();
+        let expired_json = r#"{"access_token":"","refresh_token":"rt-abc","client_id":"cid","client_secret":"cs"}"#;
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": expired_json
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        assert!(
+            auth.access_token.as_deref().is_none_or(|t| !t.is_empty()),
+            "empty access_token leaked into AuthInfo"
+        );
+        assert_eq!(auth.strategy, AuthStrategy::GoogleOAuth);
+    }
+
+    /// Counter-case: a well-formed JSON credential with a non-empty
+    /// access_token must still flow through the OAuth path unchanged.
+    #[test]
+    fn test_extract_auth_gemini_cli_valid_json_keeps_access_token() {
+        let adapter = ClaudeAdapter::new();
+        let valid_json = r#"{"access_token":"ya29.valid","refresh_token":"rt"}"#;
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": valid_json
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        assert_eq!(auth.access_token.as_deref(), Some("ya29.valid"));
+        assert_eq!(auth.strategy, AuthStrategy::GoogleOAuth);
+    }
+
+    /// 回归:从 oauth_creds.json 复制时常带前导换行/空格。未 trim 时
+    /// `starts_with('{')` 会落空,导致误分类为 `ProviderType::Gemini`,再
+    /// 以 raw JSON 当 `x-goog-api-key` 发出去触发 401。trim 应在 provider
+    /// 类型判定和 OAuth 解析前统一生效。
+    #[test]
+    fn test_extract_auth_gemini_cli_json_with_leading_whitespace_classifies_correctly() {
+        let adapter = ClaudeAdapter::new();
+        let valid_json = r#"{"access_token":"ya29.valid","refresh_token":"rt"}"#;
+        let key_with_whitespace = format!("\n  {valid_json}\n");
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": key_with_whitespace
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(adapter.provider_type(&provider), ProviderType::GeminiCli);
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        assert_eq!(auth.access_token.as_deref(), Some("ya29.valid"));
+        assert_eq!(auth.strategy, AuthStrategy::GoogleOAuth);
+    }
+
+    /// 回归:裸 `ya29.` access_token 若带前导换行,也应被 trim 后识别为
+    /// Gemini CLI OAuth,避免前导空白把 `starts_with("ya29.")` 检查顶穿。
+    #[test]
+    fn test_extract_auth_gemini_cli_access_token_with_leading_newline_classifies_correctly() {
+        let adapter = ClaudeAdapter::new();
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": "\nya29.raw-token-value\n"
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(adapter.provider_type(&provider), ProviderType::GeminiCli);
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        assert_eq!(auth.access_token.as_deref(), Some("ya29.raw-token-value"));
+        assert_eq!(auth.strategy, AuthStrategy::GoogleOAuth);
+    }
+
     #[test]
     fn test_provider_type_detection() {
         let adapter = ClaudeAdapter::new();
@@ -850,6 +1083,24 @@ mod tests {
         );
         assert!(adapter.needs_transform(&openai_responses_provider));
 
+        let gemini_native_provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": "test-key"
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+        assert!(adapter.needs_transform(&gemini_native_provider));
+        assert_eq!(
+            adapter.provider_type(&gemini_native_provider),
+            ProviderType::Gemini
+        );
+
         // meta takes precedence over legacy settings_config fields
         let meta_precedence_over_settings = create_provider_with_meta(
             json!({
@@ -957,11 +1208,106 @@ mod tests {
             "max_tokens": 128
         });
 
-        let transformed =
-            transform_claude_request_for_api_format(body, &provider, "openai_responses").unwrap();
+        let transformed = transform_claude_request_for_api_format(
+            body,
+            &provider,
+            "openai_responses",
+            None,
+            None,
+        )
+        .unwrap();
 
         assert_eq!(transformed["model"], "gpt-5.4");
         assert!(transformed.get("input").is_some());
         assert!(transformed.get("max_output_tokens").is_some());
     }
+
+    #[test]
+    fn test_transform_claude_request_for_api_format_gemini_native() {
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://generativelanguage.googleapis.com",
+                    "ANTHROPIC_API_KEY": "test-key"
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("gemini_native".to_string()),
+                ..Default::default()
+            },
+        );
+        let body = json!({
+            "model": "gemini-2.5-pro",
+            "system": "You are helpful.",
+            "messages": [{ "role": "user", "content": "hello" }],
+            "max_tokens": 64
+        });
+
+        let transformed =
+            transform_claude_request_for_api_format(body, &provider, "gemini_native", None, None)
+                .unwrap();
+
+        assert!(transformed.get("contents").is_some());
+        assert_eq!(
+            transformed["systemInstruction"]["parts"][0]["text"],
+            "You are helpful."
+        );
+        assert_eq!(transformed["generationConfig"]["maxOutputTokens"], 64);
+    }
+
+    #[test]
+    fn test_transform_claude_request_for_api_format_openai_chat_skips_prompt_cache_key_by_default()
+    {
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://api.example.com",
+                    "ANTHROPIC_API_KEY": "test-key"
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("openai_chat".to_string()),
+                ..Default::default()
+            },
+        );
+        let body = json!({
+            "model": "gpt-5.4",
+            "messages": [{ "role": "user", "content": "hello" }],
+            "max_tokens": 64
+        });
+
+        let transformed =
+            transform_claude_request_for_api_format(body, &provider, "openai_chat", None, None)
+                .unwrap();
+
+        assert!(transformed.get("prompt_cache_key").is_none());
+    }
+
+    #[test]
+    fn test_transform_claude_request_for_api_format_openai_chat_keeps_explicit_prompt_cache_key() {
+        let provider = create_provider_with_meta(
+            json!({
+                "env": {
+                    "ANTHROPIC_BASE_URL": "https://api.example.com",
+                    "ANTHROPIC_API_KEY": "test-key"
+                }
+            }),
+            ProviderMeta {
+                api_format: Some("openai_chat".to_string()),
+                prompt_cache_key: Some("claude-cache-route".to_string()),
+                ..Default::default()
+            },
+        );
+        let body = json!({
+            "model": "gpt-5.4",
+            "messages": [{ "role": "user", "content": "hello" }],
+            "max_tokens": 64
+        });
+
+        let transformed =
+            transform_claude_request_for_api_format(body, &provider, "openai_chat", None, None)
+                .unwrap();
+
+        assert_eq!(transformed["prompt_cache_key"], "claude-cache-route");
+    }
 }

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

@@ -70,6 +70,11 @@ impl GeminiAdapter {
 
     /// 解析 OAuth 凭证
     pub fn parse_oauth_credentials(&self, key: &str) -> Option<OAuthCredentials> {
+        // 防御性 trim:前端在 input 事件中会 trim,但 JSON 编辑器 / deeplink
+        // 导入 / live 回填等路径会绕过。带前导换行的 oauth_creds.json 粘贴
+        // 是常见场景,此处统一兜底。
+        let key = key.trim();
+
         // 直接是 access_token
         if key.starts_with("ya29.") {
             return Some(OAuthCredentials {
@@ -120,7 +125,12 @@ impl GeminiAdapter {
     fn extract_key_raw(&self, provider: &Provider) -> Option<String> {
         if let Some(env) = provider.settings_config.get("env") {
             // 使用 GEMINI_API_KEY
-            if let Some(key) = env.get("GEMINI_API_KEY").and_then(|v| v.as_str()) {
+            if let Some(key) = env
+                .get("GEMINI_API_KEY")
+                .and_then(|v| v.as_str())
+                .map(str::trim)
+                .filter(|s| !s.is_empty())
+            {
                 return Some(key.to_string());
             }
         }
@@ -131,6 +141,8 @@ impl GeminiAdapter {
             .get("apiKey")
             .or_else(|| provider.settings_config.get("api_key"))
             .and_then(|v| v.as_str())
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
         {
             return Some(key.to_string());
         }

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

@@ -0,0 +1,338 @@
+//! Gemini tool schema helpers.
+//!
+//! Gemini `FunctionDeclaration` supports two schema channels:
+//! - `parameters`: a restricted `Schema` subset
+//! - `parametersJsonSchema`: richer JSON Schema via arbitrary JSON `Value`
+//!
+//! Anthropic tool schemas are closer to JSON Schema, so we choose the richer
+//! channel when unsupported `Schema` fields are present.
+
+use serde_json::{json, Map, Value};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum GeminiFunctionParameters {
+    Schema(Value),
+    JsonSchema(Value),
+}
+
+pub fn build_gemini_function_parameters(input_schema: Value) -> GeminiFunctionParameters {
+    let schema = ensure_object_schema(normalize_json_schema(input_schema));
+
+    if requires_parameters_json_schema(&schema) {
+        GeminiFunctionParameters::JsonSchema(schema)
+    } else {
+        GeminiFunctionParameters::Schema(to_gemini_schema(schema))
+    }
+}
+
+/// Vertex AI rejects FunctionDeclarations whose `parameters` schema lacks an
+/// explicit `type: "object"`, returning:
+///
+/// > functionDeclaration parameters schema should be of type OBJECT.
+///
+/// Anthropic tools sometimes arrive with empty or type-less `input_schema`
+/// (e.g. no-argument tools like Claude Code's `TodoRead`). Normalize those to
+/// `{type: "object", properties: {}}` so the Gemini upstream accepts them.
+///
+/// References: google-gemini/generative-ai-python#423, BerriAI/litellm#5055.
+fn ensure_object_schema(schema: Value) -> Value {
+    match schema {
+        Value::Object(mut obj) => {
+            obj.entry("type".to_string())
+                .or_insert_with(|| json!("object"));
+            if obj.get("type").and_then(|v| v.as_str()) == Some("object") {
+                obj.entry("properties".to_string())
+                    .or_insert_with(|| json!({}));
+            }
+            Value::Object(obj)
+        }
+        other => other,
+    }
+}
+
+fn normalize_json_schema(schema: Value) -> Value {
+    match schema {
+        Value::Object(mut obj) => {
+            obj.remove("$schema");
+            obj.remove("$id");
+
+            if let Some(properties) = obj
+                .get_mut("properties")
+                .and_then(|value| value.as_object_mut())
+            {
+                for value in properties.values_mut() {
+                    *value = normalize_json_schema(value.clone());
+                }
+            }
+
+            if let Some(items) = obj.get_mut("items") {
+                *items = normalize_json_schema(items.clone());
+            }
+
+            for key in ["anyOf", "oneOf", "allOf", "prefixItems"] {
+                if let Some(values) = obj.get_mut(key).and_then(|value| value.as_array_mut()) {
+                    for value in values.iter_mut() {
+                        *value = normalize_json_schema(value.clone());
+                    }
+                }
+            }
+
+            for key in ["not", "if", "then", "else", "additionalProperties"] {
+                if let Some(value) = obj.get_mut(key) {
+                    *value = normalize_json_schema(value.clone());
+                }
+            }
+
+            Value::Object(obj)
+        }
+        Value::Array(values) => {
+            Value::Array(values.into_iter().map(normalize_json_schema).collect())
+        }
+        other => other,
+    }
+}
+
+fn requires_parameters_json_schema(schema: &Value) -> bool {
+    match schema {
+        Value::Object(obj) => object_requires_parameters_json_schema(obj),
+        Value::Array(values) => values.iter().any(requires_parameters_json_schema),
+        _ => false,
+    }
+}
+
+fn object_requires_parameters_json_schema(obj: &Map<String, Value>) -> bool {
+    for (key, value) in obj {
+        match key.as_str() {
+            "type" => {
+                if value.is_array() {
+                    return true;
+                }
+            }
+            "format" | "title" | "description" | "nullable" | "enum" | "maxItems" | "minItems"
+            | "required" | "minProperties" | "maxProperties" | "minLength" | "maxLength"
+            | "pattern" | "example" | "propertyOrdering" | "default" | "minimum" | "maximum" => {}
+            "properties" => {
+                let Some(properties) = value.as_object() else {
+                    return true;
+                };
+                if properties.values().any(requires_parameters_json_schema) {
+                    return true;
+                }
+            }
+            "items" => {
+                if !value.is_object() || requires_parameters_json_schema(value) {
+                    return true;
+                }
+            }
+            "anyOf" => {
+                let Some(values) = value.as_array() else {
+                    return true;
+                };
+                if values.iter().any(requires_parameters_json_schema) {
+                    return true;
+                }
+            }
+            // JSON Schema keywords that Gemini `parameters` does not accept.
+            "$ref"
+            | "$defs"
+            | "definitions"
+            | "additionalProperties"
+            | "unevaluatedProperties"
+            | "patternProperties"
+            | "oneOf"
+            | "allOf"
+            | "const"
+            | "not"
+            | "if"
+            | "then"
+            | "else"
+            | "dependentRequired"
+            | "dependentSchemas"
+            | "contains"
+            | "minContains"
+            | "maxContains"
+            | "prefixItems"
+            | "exclusiveMinimum"
+            | "exclusiveMaximum"
+            | "multipleOf"
+            | "examples" => return true,
+            // Be conservative for unknown keywords.
+            _ => return true,
+        }
+    }
+
+    false
+}
+
+fn to_gemini_schema(schema: Value) -> Value {
+    match schema {
+        Value::Object(obj) => {
+            let mut result = Map::new();
+
+            for (key, value) in obj {
+                match key.as_str() {
+                    "type" | "format" | "title" | "description" | "nullable" | "enum"
+                    | "maxItems" | "minItems" | "required" | "minProperties" | "maxProperties"
+                    | "minLength" | "maxLength" | "pattern" | "example" | "propertyOrdering"
+                    | "default" | "minimum" | "maximum" => {
+                        result.insert(key, value);
+                    }
+                    "properties" => {
+                        if let Some(properties) = value.as_object() {
+                            let converted = properties
+                                .iter()
+                                .map(|(name, property_schema)| {
+                                    (name.clone(), to_gemini_schema(property_schema.clone()))
+                                })
+                                .collect();
+                            result.insert("properties".to_string(), Value::Object(converted));
+                        }
+                    }
+                    "items" if value.is_object() => {
+                        result.insert("items".to_string(), to_gemini_schema(value));
+                    }
+                    "anyOf" => {
+                        if let Some(values) = value.as_array() {
+                            result.insert(
+                                "anyOf".to_string(),
+                                Value::Array(
+                                    values
+                                        .iter()
+                                        .map(|value| to_gemini_schema(value.clone()))
+                                        .collect(),
+                                ),
+                            );
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            Value::Object(result)
+        }
+        other => other,
+    }
+}
+
+pub fn build_gemini_function_declaration(
+    name: &str,
+    description: Option<&str>,
+    input_schema: Value,
+) -> Value {
+    let mut declaration = Map::new();
+    declaration.insert("name".to_string(), json!(name));
+    declaration.insert("description".to_string(), json!(description.unwrap_or("")));
+
+    match build_gemini_function_parameters(input_schema) {
+        GeminiFunctionParameters::Schema(schema) => {
+            declaration.insert("parameters".to_string(), schema);
+        }
+        GeminiFunctionParameters::JsonSchema(schema) => {
+            declaration.insert("parametersJsonSchema".to_string(), schema);
+        }
+    }
+
+    Value::Object(declaration)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn uses_schema_for_simple_openapi_subset() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "city": { "type": "string", "description": "Target city" }
+            },
+            "required": ["city"]
+        });
+
+        let result = build_gemini_function_declaration("weather", Some("Weather lookup"), schema);
+
+        assert!(result.get("parameters").is_some());
+        assert!(result.get("parametersJsonSchema").is_none());
+        assert_eq!(result["parameters"]["properties"]["city"]["type"], "string");
+    }
+
+    #[test]
+    fn uses_parameters_json_schema_for_additional_properties() {
+        let schema = json!({
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "city": { "type": "string" }
+            },
+            "required": ["city"],
+            "additionalProperties": false
+        });
+
+        let result = build_gemini_function_declaration("weather", Some("Weather lookup"), schema);
+
+        assert!(result.get("parameters").is_none());
+        assert!(result.get("parametersJsonSchema").is_some());
+        assert!(result["parametersJsonSchema"].get("$schema").is_none());
+        assert_eq!(
+            result["parametersJsonSchema"]["additionalProperties"],
+            false
+        );
+    }
+
+    #[test]
+    fn uses_parameters_json_schema_for_one_of() {
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "target": {
+                    "oneOf": [
+                        { "type": "string" },
+                        { "type": "integer" }
+                    ]
+                }
+            }
+        });
+
+        let result = build_gemini_function_declaration("search", Some("Search"), schema);
+
+        assert!(result.get("parameters").is_none());
+        assert!(result.get("parametersJsonSchema").is_some());
+    }
+
+    /// Regression for P2 (Vertex AI rejecting empty schemas): zero-argument
+    /// Anthropic tools (no `input_schema`) must produce `parameters` with an
+    /// explicit `type: "object"` and an empty `properties` map so the Gemini
+    /// upstream does not return `schema should be of type OBJECT`.
+    #[test]
+    fn empty_input_schema_produces_explicit_object_type() {
+        let result = build_gemini_function_declaration("ping", Some("no-arg"), json!({}));
+
+        assert_eq!(result["parameters"]["type"], "object");
+        assert!(result["parameters"]["properties"].is_object());
+    }
+
+    /// A schema that carries descriptive fields but no `type` is still a
+    /// zero-arg object for Gemini purposes — promote it explicitly.
+    #[test]
+    fn input_schema_missing_type_is_promoted_to_object() {
+        let result = build_gemini_function_declaration(
+            "noop",
+            None,
+            json!({ "description": "does nothing" }),
+        );
+
+        assert_eq!(result["parameters"]["type"], "object");
+        assert!(result["parameters"]["properties"].is_object());
+    }
+
+    /// Defensive: an atomic (non-object) schema is left untouched, because
+    /// forcing `type: "object"` here would corrupt primitive parameter types
+    /// that happen to flow through this path.
+    #[test]
+    fn non_object_schema_is_not_mutated() {
+        let result = build_gemini_function_declaration("bare", None, json!({ "type": "string" }));
+
+        assert_eq!(result["parameters"]["type"], "string");
+        assert!(result["parameters"].get("properties").is_none());
+    }
+}

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

@@ -0,0 +1,389 @@
+//! Gemini Native shadow state
+//!
+//! Keeps provider/session-scoped assistant content snapshots and tool call metadata
+//! so Gemini thought signatures and tool turns can be replayed without bloating
+//! the main proxy files.
+
+use serde_json::Value;
+use std::collections::{HashMap, VecDeque};
+use std::sync::RwLock;
+
+/// Composite key for a Gemini shadow session.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GeminiShadowKey {
+    pub provider_id: String,
+    pub session_id: String,
+}
+
+impl GeminiShadowKey {
+    pub fn new(provider_id: impl Into<String>, session_id: impl Into<String>) -> Self {
+        Self {
+            provider_id: provider_id.into(),
+            session_id: session_id.into(),
+        }
+    }
+}
+
+/// Gemini function call metadata captured from an assistant turn.
+#[derive(Debug, Clone, PartialEq)]
+pub struct GeminiToolCallMeta {
+    pub id: Option<String>,
+    pub name: String,
+    pub args: Value,
+    pub thought_signature: Option<String>,
+}
+
+impl GeminiToolCallMeta {
+    pub fn new(
+        id: Option<impl Into<String>>,
+        name: impl Into<String>,
+        args: Value,
+        thought_signature: Option<impl Into<String>>,
+    ) -> Self {
+        Self {
+            id: id.map(Into::into),
+            name: name.into(),
+            args,
+            thought_signature: thought_signature.map(Into::into),
+        }
+    }
+}
+
+/// Stored assistant turn snapshot.
+#[derive(Debug, Clone, PartialEq)]
+pub struct GeminiAssistantTurn {
+    pub assistant_content: Value,
+    pub tool_calls: Vec<GeminiToolCallMeta>,
+}
+
+impl GeminiAssistantTurn {
+    pub fn new(assistant_content: Value, tool_calls: Vec<GeminiToolCallMeta>) -> Self {
+        Self {
+            assistant_content,
+            tool_calls,
+        }
+    }
+}
+
+/// Session snapshot returned by read APIs.
+#[derive(Debug, Clone, PartialEq)]
+pub struct GeminiShadowSessionSnapshot {
+    pub provider_id: String,
+    pub session_id: String,
+    pub turns: Vec<GeminiAssistantTurn>,
+}
+
+#[derive(Debug, Clone)]
+struct GeminiShadowSession {
+    turns: VecDeque<GeminiAssistantTurn>,
+}
+
+impl GeminiShadowSession {
+    fn new() -> Self {
+        Self {
+            turns: VecDeque::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct GeminiShadowInner {
+    sessions: HashMap<GeminiShadowKey, GeminiShadowSession>,
+    session_order: VecDeque<GeminiShadowKey>,
+}
+
+impl GeminiShadowInner {
+    fn new() -> Self {
+        Self {
+            sessions: HashMap::new(),
+            session_order: VecDeque::new(),
+        }
+    }
+}
+
+/// Thread-safe shadow store for Gemini Native replay state.
+///
+/// The store is intentionally small and explicit:
+/// - sessions are keyed by `(provider_id, session_id)`
+/// - each session keeps only a bounded number of recent assistant turns
+/// - the oldest session is evicted first when the store is full
+#[derive(Debug)]
+pub struct GeminiShadowStore {
+    max_sessions: usize,
+    max_turns_per_session: usize,
+    inner: RwLock<GeminiShadowInner>,
+}
+
+impl Default for GeminiShadowStore {
+    fn default() -> Self {
+        Self::with_limits(200, 64)
+    }
+}
+
+impl GeminiShadowStore {
+    #[allow(dead_code)]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_limits(max_sessions: usize, max_turns_per_session: usize) -> Self {
+        Self {
+            max_sessions: max_sessions.max(1),
+            max_turns_per_session: max_turns_per_session.max(1),
+            inner: RwLock::new(GeminiShadowInner::new()),
+        }
+    }
+
+    /// Record a Gemini assistant turn for later replay.
+    pub fn record_assistant_turn(
+        &self,
+        provider_id: impl Into<String>,
+        session_id: impl Into<String>,
+        assistant_content: Value,
+        tool_calls: Vec<GeminiToolCallMeta>,
+    ) -> GeminiShadowSessionSnapshot {
+        let key = GeminiShadowKey::new(provider_id, session_id);
+        let turn = GeminiAssistantTurn::new(assistant_content, tool_calls);
+
+        let mut inner = self.inner.write().expect("gemini shadow lock poisoned");
+        Self::touch_session_order(&mut inner.session_order, &key);
+
+        let snapshot = {
+            let session = inner
+                .sessions
+                .entry(key.clone())
+                .or_insert_with(GeminiShadowSession::new);
+            session.turns.push_back(turn);
+            while session.turns.len() > self.max_turns_per_session {
+                session.turns.pop_front();
+            }
+            Self::snapshot_session(&key, session)
+        };
+        Self::prune_sessions(&mut inner, self.max_sessions);
+        snapshot
+    }
+
+    /// Get the latest assistant content for a provider/session pair.
+    #[allow(dead_code)]
+    pub fn latest_assistant_content(&self, provider_id: &str, session_id: &str) -> Option<Value> {
+        self.get_session(provider_id, session_id)
+            .and_then(|snapshot| {
+                snapshot
+                    .turns
+                    .last()
+                    .map(|turn| turn.assistant_content.clone())
+            })
+    }
+
+    /// Get the latest tool calls for a provider/session pair.
+    #[allow(dead_code)]
+    pub fn latest_tool_calls(
+        &self,
+        provider_id: &str,
+        session_id: &str,
+    ) -> Option<Vec<GeminiToolCallMeta>> {
+        self.get_session(provider_id, session_id)
+            .and_then(|snapshot| snapshot.turns.last().map(|turn| turn.tool_calls.clone()))
+    }
+
+    /// Read a full session snapshot.
+    pub fn get_session(
+        &self,
+        provider_id: &str,
+        session_id: &str,
+    ) -> Option<GeminiShadowSessionSnapshot> {
+        let key = GeminiShadowKey::new(provider_id, session_id);
+        let mut inner = self.inner.write().expect("gemini shadow lock poisoned");
+        let snapshot = inner
+            .sessions
+            .get(&key)
+            .map(|session| Self::snapshot_session(&key, session));
+        if snapshot.is_some() {
+            Self::touch_session_order(&mut inner.session_order, &key);
+        }
+        snapshot
+    }
+
+    /// Remove a single session from the store.
+    #[allow(dead_code)]
+    pub fn clear_session(&self, provider_id: &str, session_id: &str) -> bool {
+        let key = GeminiShadowKey::new(provider_id, session_id);
+        let mut inner = self.inner.write().expect("gemini shadow lock poisoned");
+        let removed = inner.sessions.remove(&key).is_some();
+        if removed {
+            Self::remove_key_from_order(&mut inner.session_order, &key);
+        }
+        removed
+    }
+
+    /// Remove all sessions for a provider.
+    #[allow(dead_code)]
+    pub fn clear_provider(&self, provider_id: &str) -> usize {
+        let mut inner = self.inner.write().expect("gemini shadow lock poisoned");
+        let keys: Vec<_> = inner
+            .sessions
+            .keys()
+            .filter(|key| key.provider_id == provider_id)
+            .cloned()
+            .collect();
+        for key in &keys {
+            inner.sessions.remove(key);
+            Self::remove_key_from_order(&mut inner.session_order, key);
+        }
+        keys.len()
+    }
+
+    /// Number of tracked sessions.
+    #[allow(dead_code)]
+    pub fn session_count(&self) -> usize {
+        self.inner
+            .read()
+            .expect("gemini shadow lock poisoned")
+            .sessions
+            .len()
+    }
+
+    fn snapshot_session(
+        key: &GeminiShadowKey,
+        session: &GeminiShadowSession,
+    ) -> GeminiShadowSessionSnapshot {
+        GeminiShadowSessionSnapshot {
+            provider_id: key.provider_id.clone(),
+            session_id: key.session_id.clone(),
+            turns: session.turns.iter().cloned().collect(),
+        }
+    }
+
+    fn touch_session_order(order: &mut VecDeque<GeminiShadowKey>, key: &GeminiShadowKey) {
+        if let Some(pos) = order.iter().position(|existing| existing == key) {
+            order.remove(pos);
+        }
+        order.push_back(key.clone());
+    }
+
+    #[allow(dead_code)]
+    fn remove_key_from_order(order: &mut VecDeque<GeminiShadowKey>, key: &GeminiShadowKey) {
+        if let Some(pos) = order.iter().position(|existing| existing == key) {
+            order.remove(pos);
+        }
+    }
+
+    fn prune_sessions(inner: &mut GeminiShadowInner, max_sessions: usize) {
+        while inner.sessions.len() > max_sessions {
+            let Some(evicted_key) = inner.session_order.pop_front() else {
+                break;
+            };
+            inner.sessions.remove(&evicted_key);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn record_and_read_latest_turn() {
+        let store = GeminiShadowStore::with_limits(8, 4);
+        let snapshot = store.record_assistant_turn(
+            "provider-a",
+            "session-1",
+            json!({"parts": [{"text": "hello", "thoughtSignature": "sig-1"}]}),
+            vec![GeminiToolCallMeta::new(
+                Some("call-1"),
+                "get_weather",
+                json!({"location": "Tokyo"}),
+                Some("sig-1"),
+            )],
+        );
+
+        assert_eq!(snapshot.provider_id, "provider-a");
+        assert_eq!(snapshot.session_id, "session-1");
+        assert_eq!(snapshot.turns.len(), 1);
+
+        let content = store
+            .latest_assistant_content("provider-a", "session-1")
+            .expect("content");
+        assert_eq!(content["parts"][0]["text"], "hello");
+        assert_eq!(content["parts"][0]["thoughtSignature"], "sig-1");
+
+        let tool_calls = store
+            .latest_tool_calls("provider-a", "session-1")
+            .expect("tool calls");
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].id.as_deref(), Some("call-1"));
+        assert_eq!(tool_calls[0].name, "get_weather");
+        assert_eq!(tool_calls[0].args["location"], "Tokyo");
+        assert_eq!(tool_calls[0].thought_signature.as_deref(), Some("sig-1"));
+    }
+
+    #[test]
+    fn sessions_are_isolated_by_provider_and_session_id() {
+        let store = GeminiShadowStore::with_limits(8, 4);
+
+        store.record_assistant_turn("provider-a", "session-1", json!({"text": "a"}), vec![]);
+        store.record_assistant_turn("provider-b", "session-1", json!({"text": "b"}), vec![]);
+        store.record_assistant_turn("provider-a", "session-2", json!({"text": "c"}), vec![]);
+
+        assert_eq!(store.session_count(), 3);
+        assert_eq!(
+            store.latest_assistant_content("provider-a", "session-1"),
+            Some(json!({"text": "a"}))
+        );
+        assert_eq!(
+            store.latest_assistant_content("provider-b", "session-1"),
+            Some(json!({"text": "b"}))
+        );
+        assert_eq!(
+            store.latest_assistant_content("provider-a", "session-2"),
+            Some(json!({"text": "c"}))
+        );
+    }
+
+    #[test]
+    fn retains_only_latest_turns_per_session() {
+        let store = GeminiShadowStore::with_limits(8, 2);
+
+        store.record_assistant_turn("provider-a", "session-1", json!({"idx": 1}), vec![]);
+        store.record_assistant_turn("provider-a", "session-1", json!({"idx": 2}), vec![]);
+        store.record_assistant_turn("provider-a", "session-1", json!({"idx": 3}), vec![]);
+
+        let snapshot = store
+            .get_session("provider-a", "session-1")
+            .expect("snapshot");
+        assert_eq!(snapshot.turns.len(), 2);
+        assert_eq!(snapshot.turns[0].assistant_content, json!({"idx": 2}));
+        assert_eq!(snapshot.turns[1].assistant_content, json!({"idx": 3}));
+    }
+
+    #[test]
+    fn evicts_oldest_session_when_capacity_is_exceeded() {
+        let store = GeminiShadowStore::with_limits(2, 2);
+
+        store.record_assistant_turn("provider-a", "session-1", json!({"idx": 1}), vec![]);
+        store.record_assistant_turn("provider-a", "session-2", json!({"idx": 2}), vec![]);
+        store.record_assistant_turn("provider-a", "session-3", json!({"idx": 3}), vec![]);
+
+        assert!(store.get_session("provider-a", "session-1").is_none());
+        assert!(store.get_session("provider-a", "session-2").is_some());
+        assert!(store.get_session("provider-a", "session-3").is_some());
+    }
+
+    #[test]
+    fn clear_session_and_provider_work() {
+        let store = GeminiShadowStore::with_limits(8, 4);
+
+        store.record_assistant_turn("provider-a", "session-1", json!({"idx": 1}), vec![]);
+        store.record_assistant_turn("provider-a", "session-2", json!({"idx": 2}), vec![]);
+        store.record_assistant_turn("provider-b", "session-3", json!({"idx": 3}), vec![]);
+
+        assert!(store.clear_session("provider-a", "session-1"));
+        assert!(store.get_session("provider-a", "session-1").is_none());
+
+        let removed = store.clear_provider("provider-a");
+        assert_eq!(removed, 1);
+        assert!(store.get_session("provider-a", "session-2").is_none());
+        assert!(store.get_session("provider-b", "session-3").is_some());
+    }
+}

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

@@ -18,10 +18,14 @@ mod codex;
 pub mod codex_oauth_auth;
 pub mod copilot_auth;
 mod gemini;
+pub(crate) mod gemini_schema;
+pub mod gemini_shadow;
 pub mod models;
 pub mod streaming;
+pub mod streaming_gemini;
 pub mod streaming_responses;
 pub mod transform;
+pub mod transform_gemini;
 pub mod transform_responses;
 
 use crate::app_config::AppType;
@@ -101,6 +105,14 @@ impl ProviderType {
     pub fn from_app_type_and_config(app_type: &AppType, provider: &Provider) -> Self {
         match app_type {
             AppType::Claude => {
+                if get_claude_api_format(provider) == "gemini_native" {
+                    let adapter = ClaudeAdapter::new();
+                    return match adapter.extract_auth(provider).map(|auth| auth.strategy) {
+                        Some(AuthStrategy::GoogleOAuth) => ProviderType::GeminiCli,
+                        _ => ProviderType::Gemini,
+                    };
+                }
+
                 // 检测是否为 GitHub Copilot
                 if let Some(meta) = provider.meta.as_ref() {
                     if meta.provider_type.as_deref() == Some("github_copilot") {

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

@@ -2,7 +2,7 @@
 //!
 //! 实现 OpenAI SSE → Anthropic SSE 格式转换
 
-use crate::proxy::sse::strip_sse_field;
+use crate::proxy::sse::{strip_sse_field, take_sse_block};
 use bytes::Bytes;
 use futures::stream::{Stream, StreamExt};
 use serde::{Deserialize, Serialize};
@@ -118,10 +118,7 @@ pub fn create_anthropic_sse_stream<E: std::error::Error + Send + 'static>(
                 Ok(bytes) => {
                     crate::proxy::sse::append_utf8_safe(&mut buffer, &mut utf8_remainder, &bytes);
 
-                    while let Some(pos) = buffer.find("\n\n") {
-                        let line = buffer[..pos].to_string();
-                        buffer = buffer[pos + 2..].to_string();
-
+                    while let Some(line) = take_sse_block(&mut buffer) {
                         if line.trim().is_empty() {
                             continue;
                         }

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

@@ -9,7 +9,7 @@
 //! 与 Chat Completions 的 delta chunk 模型完全不同，需要独立的状态机处理。
 
 use super::transform_responses::{build_anthropic_usage_from_responses, map_responses_stop_reason};
-use crate::proxy::sse::strip_sse_field;
+use crate::proxy::sse::{strip_sse_field, take_sse_block};
 use bytes::Bytes;
 use futures::stream::{Stream, StreamExt};
 use serde_json::{json, Value};
@@ -122,10 +122,7 @@ pub fn create_anthropic_sse_stream_from_responses<E: std::error::Error + Send +
                     crate::proxy::sse::append_utf8_safe(&mut buffer, &mut utf8_remainder, &bytes);
 
                     // SSE 事件由 \n\n 分隔
-                    while let Some(pos) = buffer.find("\n\n") {
-                        let block = buffer[..pos].to_string();
-                        buffer = buffer[pos + 2..].to_string();
-
+                    while let Some(block) = take_sse_block(&mut buffer) {
                         if block.trim().is_empty() {
                             continue;
                         }

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

@@ -194,23 +194,14 @@ pub(crate) fn map_responses_stop_reason(
     incomplete_reason: Option<&str>,
 ) -> Option<&'static str> {
     status.map(|s| match s {
-        "completed" => {
-            if has_tool_use {
-                "tool_use"
-            } else {
-                "end_turn"
-            }
-        }
-        "incomplete" => {
+        "completed" if has_tool_use => "tool_use",
+        "incomplete"
             if matches!(
                 incomplete_reason,
                 Some("max_output_tokens") | Some("max_tokens")
-            ) || incomplete_reason.is_none()
-            {
-                "max_tokens"
-            } else {
-                "end_turn"
-            }
+            ) || incomplete_reason.is_none() =>
+        {
+            "max_tokens"
         }
         _ => "end_turn",
     })

src-tauri/src/proxy/response_handler.rs

@@ -5,7 +5,7 @@
 use super::session::ProxySession;
 use super::usage::parser::TokenUsage;
 use super::ProxyError;
-use crate::proxy::sse::strip_sse_field;
+use crate::proxy::sse::{strip_sse_field, take_sse_block};
 use bytes::Bytes;
 use futures::stream::{Stream, StreamExt};
 use serde_json::Value;
@@ -86,10 +86,7 @@ impl StreamHandler {
                         crate::proxy::sse::append_utf8_safe(&mut buffer, &mut utf8_remainder, &bytes);
 
                         // 提取完整事件
-                        while let Some(pos) = buffer.find("\n\n") {
-                            let event_text = buffer[..pos].to_string();
-                            buffer = buffer[pos + 2..].to_string();
-
+                        while let Some(event_text) = take_sse_block(&mut buffer) {
                             for line in event_text.lines() {
                                 if let Some(data) = strip_sse_field(line, "data") {
                                     if data.trim() != "[DONE]" {

src-tauri/src/proxy/response_processor.rs

@@ -7,7 +7,7 @@ use super::{
     handler_context::{RequestContext, StreamingTimeoutConfig},
     hyper_client::ProxyResponse,
     server::ProxyState,
-    sse::strip_sse_field,
+    sse::{strip_sse_field, take_sse_block},
     usage::parser::TokenUsage,
     ProxyError,
 };
@@ -662,10 +662,7 @@ pub fn create_logged_passthrough_stream(
                     crate::proxy::sse::append_utf8_safe(&mut buffer, &mut utf8_remainder, &bytes);
 
                     // 尝试解析并记录完整的 SSE 事件
-                    while let Some(pos) = buffer.find("\n\n") {
-                        let event_text = buffer[..pos].to_string();
-                        buffer = buffer[pos + 2..].to_string();
-
+                    while let Some(event_text) = take_sse_block(&mut buffer) {
                         if !event_text.trim().is_empty() {
                             // 提取 data 部分并尝试解析为 JSON
                             for line in event_text.lines() {
@@ -726,6 +723,7 @@ mod tests {
     use crate::provider::ProviderMeta;
     use crate::proxy::failover_switch::FailoverSwitchManager;
     use crate::proxy::provider_router::ProviderRouter;
+    use crate::proxy::providers::gemini_shadow::GeminiShadowStore;
     use crate::proxy::types::{ProxyConfig, ProxyStatus};
     use rust_decimal::Decimal;
     use std::collections::HashMap;
@@ -846,6 +844,7 @@ mod tests {
             start_time: Arc::new(RwLock::new(None)),
             current_providers: Arc::new(RwLock::new(HashMap::new())),
             provider_router: Arc::new(ProviderRouter::new(db.clone())),
+            gemini_shadow: Arc::new(GeminiShadowStore::default()),
             app_handle: None,
             failover_manager: Arc::new(FailoverSwitchManager::new(db)),
         }

src-tauri/src/proxy/server.rs

@@ -10,7 +10,8 @@
 
 use super::{
     failover_switch::FailoverSwitchManager, handlers, log_codes::srv as log_srv,
-    provider_router::ProviderRouter, types::*, ProxyError,
+    provider_router::ProviderRouter, providers::gemini_shadow::GeminiShadowStore, types::*,
+    ProxyError,
 };
 use crate::database::Database;
 use axum::{
@@ -35,6 +36,8 @@ pub struct ProxyState {
     pub current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
     /// 共享的 ProviderRouter（持有熔断器状态，跨请求保持）
     pub provider_router: Arc<ProviderRouter>,
+    /// Gemini Native shadow state，用于 thoughtSignature / tool call 回放
+    pub gemini_shadow: Arc<GeminiShadowStore>,
     /// AppHandle，用于发射事件和更新托盘菜单
     pub app_handle: Option<tauri::AppHandle>,
     /// 故障转移切换管理器
@@ -68,6 +71,7 @@ impl ProxyServer {
             start_time: Arc::new(RwLock::new(None)),
             current_providers: Arc::new(RwLock::new(std::collections::HashMap::new())),
             provider_router,
+            gemini_shadow: Arc::new(GeminiShadowStore::default()),
             app_handle,
             failover_manager,
         };

src-tauri/src/proxy/session.rs

@@ -242,6 +242,12 @@ pub fn extract_session_id(
     body: &serde_json::Value,
     client_format: &str,
 ) -> SessionIdResult {
+    if client_format == "claude" {
+        if let Some(result) = extract_claude_session(headers, body) {
+            return result;
+        }
+    }
+
     // Codex 请求特殊处理
     if client_format == "codex" || client_format == "openai" {
         if let Some(result) = extract_codex_session(headers, body) {
@@ -258,6 +264,28 @@ pub fn extract_session_id(
     generate_new_session_id()
 }
 
+/// 提取 Claude Session ID
+fn extract_claude_session(
+    headers: &HeaderMap,
+    body: &serde_json::Value,
+) -> Option<SessionIdResult> {
+    for header_name in &["x-claude-code-session-id", "claude-code-session-id"] {
+        if let Some(value) = headers.get(*header_name) {
+            if let Ok(session_id) = value.to_str() {
+                if !session_id.is_empty() {
+                    return Some(SessionIdResult {
+                        session_id: session_id.to_string(),
+                        source: SessionIdSource::Header,
+                        client_provided: true,
+                    });
+                }
+            }
+        }
+    }
+
+    extract_from_metadata(body)
+}
+
 /// 提取 Codex Session ID
 fn extract_codex_session(headers: &HeaderMap, body: &serde_json::Value) -> Option<SessionIdResult> {
     // 1. 从 headers 提取
@@ -515,6 +543,47 @@ mod tests {
         assert!(result.client_provided);
     }
 
+    #[test]
+    fn test_extract_session_from_claude_header() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "x-claude-code-session-id",
+            "d937243f-2702-4f20-97b6-c9682235ab81".parse().unwrap(),
+        );
+        let body = json!({
+            "model": "claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "Hello"}]
+        });
+
+        let result = extract_session_id(&headers, &body, "claude");
+
+        assert_eq!(result.session_id, "d937243f-2702-4f20-97b6-c9682235ab81");
+        assert_eq!(result.source, SessionIdSource::Header);
+        assert!(result.client_provided);
+    }
+
+    #[test]
+    fn test_extract_session_from_claude_header_precedes_metadata() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "x-claude-code-session-id",
+            "header-session-123".parse().unwrap(),
+        );
+        let body = json!({
+            "model": "claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "metadata": {
+                "session_id": "my-session-123"
+            }
+        });
+
+        let result = extract_session_id(&headers, &body, "claude");
+
+        assert_eq!(result.session_id, "header-session-123");
+        assert_eq!(result.source, SessionIdSource::Header);
+        assert!(result.client_provided);
+    }
+
     #[test]
     fn test_extract_session_from_codex_previous_response_id() {
         let headers = HeaderMap::new();

src-tauri/src/proxy/sse.rs

@@ -4,6 +4,24 @@ pub(crate) fn strip_sse_field<'a>(line: &'a str, field: &str) -> Option<&'a str>
         .or_else(|| line.strip_prefix(&format!("{field}:")))
 }
 
+#[inline]
+pub(crate) fn take_sse_block(buffer: &mut String) -> Option<String> {
+    let mut best: Option<(usize, usize)> = None;
+
+    for (delimiter, len) in [("\r\n\r\n", 4usize), ("\n\n", 2usize)] {
+        if let Some(pos) = buffer.find(delimiter) {
+            if best.is_none_or(|(best_pos, _)| pos < best_pos) {
+                best = Some((pos, len));
+            }
+        }
+    }
+
+    let (pos, len) = best?;
+    let block = buffer[..pos].to_string();
+    buffer.drain(..pos + len);
+    Some(block)
+}
+
 /// Append raw bytes to a UTF-8 `String` buffer, correctly handling multi-byte
 /// characters that are split across chunk boundaries.
 ///
@@ -68,7 +86,7 @@ pub(crate) fn append_utf8_safe(buffer: &mut String, remainder: &mut Vec<u8>, new
 
 #[cfg(test)]
 mod tests {
-    use super::{append_utf8_safe, strip_sse_field};
+    use super::{append_utf8_safe, strip_sse_field, take_sse_block};
 
     #[test]
     fn strip_sse_field_accepts_optional_space() {
@@ -91,6 +109,28 @@ mod tests {
         assert_eq!(strip_sse_field("id:1", "data"), None);
     }
 
+    #[test]
+    fn take_sse_block_supports_lf_delimiters() {
+        let mut buffer = "data: {\"ok\":true}\n\nrest".to_string();
+
+        assert_eq!(
+            take_sse_block(&mut buffer),
+            Some("data: {\"ok\":true}".to_string())
+        );
+        assert_eq!(buffer, "rest");
+    }
+
+    #[test]
+    fn take_sse_block_supports_crlf_delimiters() {
+        let mut buffer = "data: {\"ok\":true}\r\n\r\nrest".to_string();
+
+        assert_eq!(
+            take_sse_block(&mut buffer),
+            Some("data: {\"ok\":true}".to_string())
+        );
+        assert_eq!(buffer, "rest");
+    }
+
     // ------------------------------------------------------------------
     // append_utf8_safe tests
     // ------------------------------------------------------------------

src-tauri/src/proxy/thinking_rectifier.rs

@@ -52,6 +52,14 @@ pub fn should_rectify_thinking_signature(
         return true;
     }
 
+    // 场景1b: Gemini/第三方渠道返回 "Thought signature is not valid"
+    // 错误示例: "Unable to submit request because Thought signature is not valid"
+    if lower.contains("thought signature")
+        && (lower.contains("not valid") || lower.contains("invalid"))
+    {
+        return true;
+    }
+
     // 场景2: assistant 消息必须以 thinking block 开头
     // 错误示例: "must start with a thinking block"
     if lower.contains("must start with a thinking block") {
@@ -280,6 +288,16 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_detect_invalid_thought_signature_message() {
+        assert!(should_rectify_thinking_signature(
+            Some(
+                "Unable to submit request because Thought signature is not valid.. Learn more: https://example.com/help"
+            ),
+            &enabled_config()
+        ));
+    }
+
     #[test]
     fn test_detect_invalid_signature_nested_json() {
         // 测试嵌套 JSON 格式的错误消息（第三方渠道常见格式）
@@ -290,6 +308,15 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_detect_invalid_thought_signature_nested_json() {
+        let nested_error = r#"{"error":{"message":"Unable to submit request because Thought signature is not valid.. Learn more: https://example.com/help","type":"upstream_error","param":"","code":400}}"#;
+        assert!(should_rectify_thinking_signature(
+            Some(nested_error),
+            &enabled_config()
+        ));
+    }
+
     #[test]
     fn test_detect_thinking_expected() {
         assert!(should_rectify_thinking_signature(

src-tauri/src/services/provider/endpoints.rs

@@ -27,7 +27,7 @@ pub fn get_custom_endpoints(
     }
 
     let mut result: Vec<_> = meta.custom_endpoints.values().cloned().collect();
-    result.sort_by(|a, b| b.added_at.cmp(&a.added_at));
+    result.sort_by_key(|ep| std::cmp::Reverse(ep.added_at));
     Ok(result)
 }
 

src-tauri/src/services/session_usage_codex.rs

@@ -297,18 +297,16 @@ fn sync_single_codex_file(db: &Database, file_path: &Path) -> Result<(u32, u32),
         };
 
         match event_type {
-            "session_meta" => {
-                if state.session_id.is_none() {
-                    let payload = value.get("payload");
-                    state.session_id = payload
-                        .and_then(|p| {
-                            p.get("session_id")
-                                .or_else(|| p.get("sessionId"))
-                                .or_else(|| p.get("id"))
-                        })
-                        .and_then(|v| v.as_str())
-                        .map(|s| s.to_string());
-                }
+            "session_meta" if state.session_id.is_none() => {
+                let payload = value.get("payload");
+                state.session_id = payload
+                    .and_then(|p| {
+                        p.get("session_id")
+                            .or_else(|| p.get("sessionId"))
+                            .or_else(|| p.get("id"))
+                    })
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string());
             }
             "turn_context" => {
                 if let Some(payload) = value.get("payload") {

src-tauri/src/services/skill.rs

@@ -1268,7 +1268,7 @@ impl SkillService {
             }
         }
 
-        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        entries.sort_by_key(|entry| std::cmp::Reverse(entry.created_at));
         Ok(entries)
     }
 
@@ -1772,7 +1772,7 @@ impl SkillService {
         let results: Vec<Result<Vec<DiscoverableSkill>>> =
             futures::future::join_all(fetch_tasks).await;
 
-        for (repo, result) in enabled_repos.into_iter().zip(results.into_iter()) {
+        for (repo, result) in enabled_repos.into_iter().zip(results) {
             match result {
                 Ok(repo_skills) => skills.extend(repo_skills),
                 Err(e) => log::warn!("获取仓库 {}/{} 技能失败: {}", repo.owner, repo.name, e),
@@ -1781,7 +1781,7 @@ impl SkillService {
 
         // 去重并排序
         Self::deduplicate_discoverable_skills(&mut skills);
-        skills.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        skills.sort_by_key(|skill| skill.name.to_lowercase());
 
         Ok(skills)
     }
@@ -1848,7 +1848,7 @@ impl SkillService {
             }
         }
 
-        skills.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        skills.sort_by_key(|skill| skill.name.to_lowercase());
 
         Ok(skills)
     }

src-tauri/src/services/stream_check.rs

@@ -12,8 +12,10 @@ use std::time::Instant;
 use crate::app_config::AppType;
 use crate::error::AppError;
 use crate::provider::Provider;
+use crate::proxy::gemini_url::{normalize_gemini_model_id, resolve_gemini_native_url};
 use crate::proxy::providers::copilot_auth;
 use crate::proxy::providers::transform::anthropic_to_openai;
+use crate::proxy::providers::transform_gemini::anthropic_to_gemini;
 use crate::proxy::providers::transform_responses::anthropic_to_responses;
 use crate::proxy::providers::{get_adapter, AuthInfo, AuthStrategy};
 
@@ -288,6 +290,8 @@ impl StreamCheckService {
     /// 根据供应商的 api_format 选择请求格式：
     /// - "anthropic" (默认): Anthropic Messages API (/v1/messages)
     /// - "openai_chat": OpenAI Chat Completions API (/v1/chat/completions)
+    /// - "openai_responses": OpenAI Responses API (/v1/responses)
+    /// - "gemini_native": Gemini Native streamGenerateContent
     ///
     /// `extra_headers` 是一个可选的供应商级自定义 header 集合（从 OpenClaw
     /// 的 `settings_config.headers` 或 OpenCode 的 `settings_config.options.headers`
@@ -329,8 +333,14 @@ impl StreamCheckService {
             .unwrap_or(false);
         let is_openai_chat = effective_api_format == "openai_chat";
         let is_openai_responses = effective_api_format == "openai_responses";
-        let url =
-            Self::resolve_claude_stream_url(base, auth.strategy, effective_api_format, is_full_url);
+        let is_gemini_native = effective_api_format == "gemini_native";
+        let url = Self::resolve_claude_stream_url(
+            base,
+            auth.strategy,
+            effective_api_format,
+            is_full_url,
+            model,
+        );
 
         let max_tokens = if is_openai_responses { 16 } else { 1 };
 
@@ -352,6 +362,9 @@ impl StreamCheckService {
         let body = if is_openai_responses {
             anthropic_to_responses(anthropic_body, Some(&provider.id), is_codex_oauth)
                 .map_err(|e| AppError::Message(format!("Failed to build test request: {e}")))?
+        } else if is_gemini_native {
+            anthropic_to_gemini(anthropic_body)
+                .map_err(|e| AppError::Message(format!("Failed to build test request: {e}")))?
         } else if is_openai_chat {
             anthropic_to_openai(anthropic_body)
                 .map_err(|e| AppError::Message(format!("Failed to build test request: {e}")))?
@@ -387,6 +400,23 @@ impl StreamCheckService {
                 .header("x-vscode-user-agent-library-version", "electron-fetch")
                 .header("x-request-id", &request_id)
                 .header("x-agent-task-id", &request_id);
+        } else if is_gemini_native {
+            request_builder = match auth.strategy {
+                AuthStrategy::GoogleOAuth => {
+                    let token = auth.access_token.as_ref().unwrap_or(&auth.api_key);
+                    request_builder
+                        .header("authorization", format!("Bearer {token}"))
+                        .header("x-goog-api-client", "GeminiCLI/1.0")
+                        .header("content-type", "application/json")
+                        .header("accept", "text/event-stream")
+                        .header("accept-encoding", "identity")
+                }
+                _ => request_builder
+                    .header("x-goog-api-key", &auth.api_key)
+                    .header("content-type", "application/json")
+                    .header("accept", "text/event-stream")
+                    .header("accept-encoding", "identity"),
+            };
         } else if is_openai_chat || is_openai_responses {
             // OpenAI-compatible targets: Bearer auth + SSE headers only
             request_builder = request_builder
@@ -568,13 +598,16 @@ impl StreamCheckService {
         extra_headers: Option<&serde_json::Map<String, serde_json::Value>>,
     ) -> Result<(u16, String), AppError> {
         let base = base_url.trim_end_matches('/');
+        // Strip `models/` resource-name prefix from the model id — see
+        // `normalize_gemini_model_id` for rationale.
+        let normalized_model = normalize_gemini_model_id(model);
         // Gemini 原生 API: /v1beta/models/{model}:streamGenerateContent?alt=sse
         // 智能处理 /v1beta 路径：如果 base_url 不包含版本路径，则添加 /v1beta
         // alt=sse 参数使 API 返回 SSE 格式（text/event-stream）而非 JSON 数组
         let url = if base.contains("/v1beta") || base.contains("/v1/") {
-            format!("{base}/models/{model}:streamGenerateContent?alt=sse")
+            format!("{base}/models/{normalized_model}:streamGenerateContent?alt=sse")
         } else {
-            format!("{base}/v1beta/models/{model}:streamGenerateContent?alt=sse")
+            format!("{base}/v1beta/models/{normalized_model}:streamGenerateContent?alt=sse")
         };
 
         // Gemini 原生请求体格式
@@ -1292,7 +1325,19 @@ impl StreamCheckService {
         auth_strategy: AuthStrategy,
         api_format: &str,
         is_full_url: bool,
+        model: &str,
     ) -> String {
+        if api_format == "gemini_native" {
+            // Strip an optional `models/` resource-name prefix so that model
+            // identifiers copied from Gemini SDK outputs (e.g.
+            // `models/gemini-2.5-pro`) don't produce a doubled
+            // `/v1beta/models/models/...` URL.
+            let normalized_model = normalize_gemini_model_id(model);
+            let endpoint =
+                format!("/v1beta/models/{normalized_model}:streamGenerateContent?alt=sse");
+            return resolve_gemini_native_url(base_url, &endpoint, is_full_url);
+        }
+
         if is_full_url {
             return base_url.to_string();
         }
@@ -1621,6 +1666,7 @@ mod tests {
             AuthStrategy::Bearer,
             "openai_chat",
             true,
+            "gpt-5.4",
         );
 
         assert_eq!(url, "https://relay.example/v1/chat/completions");
@@ -1633,6 +1679,7 @@ mod tests {
             AuthStrategy::GitHubCopilot,
             "openai_chat",
             false,
+            "gpt-5.4",
         );
 
         assert_eq!(url, "https://api.githubcopilot.com/chat/completions");
@@ -1645,6 +1692,7 @@ mod tests {
             AuthStrategy::GitHubCopilot,
             "openai_responses",
             false,
+            "gpt-5.4",
         );
 
         assert_eq!(url, "https://api.githubcopilot.com/v1/responses");
@@ -1657,6 +1705,7 @@ mod tests {
             AuthStrategy::Bearer,
             "openai_chat",
             false,
+            "gpt-5.4",
         );
 
         assert_eq!(url, "https://example.com/v1/chat/completions");
@@ -1669,6 +1718,7 @@ mod tests {
             AuthStrategy::Bearer,
             "openai_responses",
             false,
+            "gpt-5.4",
         );
 
         assert_eq!(url, "https://example.com/v1/responses");
@@ -1681,11 +1731,78 @@ mod tests {
             AuthStrategy::Anthropic,
             "anthropic",
             false,
+            "claude-sonnet-4-6",
         );
 
         assert_eq!(url, "https://api.anthropic.com/v1/messages");
     }
 
+    #[test]
+    fn test_resolve_claude_stream_url_for_gemini_native() {
+        let url = StreamCheckService::resolve_claude_stream_url(
+            "https://generativelanguage.googleapis.com",
+            AuthStrategy::Google,
+            "gemini_native",
+            false,
+            "gemini-2.5-flash",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn test_resolve_claude_stream_url_for_gemini_native_full_url_openai_compat_base() {
+        let url = StreamCheckService::resolve_claude_stream_url(
+            "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+            AuthStrategy::Google,
+            "gemini_native",
+            true,
+            "gemini-2.5-flash",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse"
+        );
+    }
+
+    #[test]
+    fn test_resolve_claude_stream_url_for_gemini_native_opaque_full_url() {
+        let url = StreamCheckService::resolve_claude_stream_url(
+            "https://relay.example/custom/generate-content",
+            AuthStrategy::Google,
+            "gemini_native",
+            true,
+            "gemini-2.5-flash",
+        );
+
+        assert_eq!(url, "https://relay.example/custom/generate-content?alt=sse");
+    }
+
+    /// Regression: Gemini SDK outputs commonly surface model ids as the
+    /// resource-name form `models/gemini-2.5-pro`. Interpolating that raw
+    /// value used to produce `/v1beta/models/models/gemini-2.5-pro:...`
+    /// which the upstream rejects and the health check records as a
+    /// false-negative for an otherwise valid provider.
+    #[test]
+    fn test_resolve_claude_stream_url_for_gemini_native_strips_models_prefix() {
+        let url = StreamCheckService::resolve_claude_stream_url(
+            "https://generativelanguage.googleapis.com",
+            AuthStrategy::Google,
+            "gemini_native",
+            false,
+            "models/gemini-2.5-pro",
+        );
+
+        assert_eq!(
+            url,
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:streamGenerateContent?alt=sse"
+        );
+    }
+
     #[test]
     fn test_resolve_codex_stream_urls_for_full_url_mode() {
         let urls = StreamCheckService::resolve_codex_stream_urls(

src-tauri/src/services/webdav_auto_sync.rs

@@ -173,10 +173,7 @@ async fn run_worker_loop(
         let started_at = Instant::now();
         let mut merged_count = 1usize;
 
-        loop {
-            let Some(wait_for) = auto_sync_wait_duration(started_at, Instant::now()) else {
-                break;
-            };
+        while let Some(wait_for) = auto_sync_wait_duration(started_at, Instant::now()) {
             let timeout = tokio::time::timeout(wait_for, rx.recv()).await;
 
             match timeout {

src/components/providers/forms/ClaudeFormFields.tsx

@@ -113,7 +113,7 @@ interface ClaudeFormFieldsProps {
   // Speed Test Endpoints
   speedTestEndpoints: EndpointCandidate[];
 
-  // API Format (for third-party providers that use OpenAI Chat Completions format)
+  // API Format (for Claude-compatible providers that need request/response conversion)
   apiFormat: ClaudeApiFormat;
   onApiFormatChange: (format: ClaudeApiFormat) => void;
 
@@ -436,7 +436,14 @@ export function ClaudeFormFields({
               ? t("providerForm.apiHintResponses")
               : apiFormat === "openai_chat"
                 ? t("providerForm.apiHintOAI")
-                : t("providerForm.apiHint")
+                : apiFormat === "gemini_native"
+                  ? t("providerForm.apiHintGeminiNative")
+                  : t("providerForm.apiHint")
+          }
+          fullUrlHint={
+            apiFormat === "gemini_native"
+              ? t("providerForm.fullUrlHintGeminiNative")
+              : undefined
           }
           onManageClick={() => onEndpointModalToggle(true)}
           showFullUrlToggle={true}
@@ -511,6 +518,11 @@ export function ClaudeFormFields({
                         defaultValue: "OpenAI Responses API (需转换)",
                       })}
                     </SelectItem>
+                    <SelectItem value="gemini_native">
+                      {t("providerForm.apiFormatGeminiNative", {
+                        defaultValue: "Gemini Native generateContent (需转换)",
+                      })}
+                    </SelectItem>
                   </SelectContent>
                 </Select>
                 <p className="text-xs text-muted-foreground">

src/components/providers/forms/shared/EndpointField.tsx

@@ -11,6 +11,7 @@ interface EndpointFieldProps {
   onChange: (value: string) => void;
   placeholder: string;
   hint?: string;
+  fullUrlHint?: string;
   showManageButton?: boolean;
   onManageClick?: () => void;
   manageButtonLabel?: string;
@@ -26,6 +27,7 @@ export function EndpointField({
   onChange,
   placeholder,
   hint,
+  fullUrlHint,
   showManageButton = true,
   onManageClick,
   manageButtonLabel,
@@ -40,7 +42,8 @@ export function EndpointField({
   });
   const effectiveHint =
     showFullUrlToggle && isFullUrl
-      ? t("providerForm.fullUrlHint", {
+      ? fullUrlHint ||
+        t("providerForm.fullUrlHint", {
           defaultValue:
             "💡 请填写完整请求 URL，并且必须开启代理后使用；代理将直接使用此 URL，不拼接路径",
         })

src/config/claudeProviderPresets.ts

@@ -49,7 +49,12 @@ export interface ProviderPreset {
   // - "anthropic" (默认): Anthropic Messages API 格式，直接透传
   // - "openai_chat": OpenAI Chat Completions 格式，需要格式转换
   // - "openai_responses": OpenAI Responses API 格式，需要格式转换
-  apiFormat?: "anthropic" | "openai_chat" | "openai_responses";
+  // - "gemini_native": Gemini Native generateContent API 格式，需要格式转换
+  apiFormat?:
+    | "anthropic"
+    | "openai_chat"
+    | "openai_responses"
+    | "gemini_native";
 
   // 供应商类型标识（用于特殊供应商检测）
   // - "github_copilot": GitHub Copilot 供应商（需要 OAuth 认证）
@@ -80,6 +85,27 @@ export const providerPresets: ProviderPreset[] = [
     icon: "anthropic",
     iconColor: "#D4915D",
   },
+  {
+    name: "Gemini Native",
+    websiteUrl: "https://ai.google.dev/gemini-api",
+    apiKeyUrl: "https://aistudio.google.com/app/apikey",
+    apiKeyField: "ANTHROPIC_API_KEY",
+    settingsConfig: {
+      env: {
+        ANTHROPIC_BASE_URL: "https://generativelanguage.googleapis.com",
+        ANTHROPIC_API_KEY: "",
+        ANTHROPIC_MODEL: "gemini-2.5-pro",
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: "gemini-2.5-flash",
+        ANTHROPIC_DEFAULT_SONNET_MODEL: "gemini-2.5-pro",
+        ANTHROPIC_DEFAULT_OPUS_MODEL: "gemini-2.5-pro",
+      },
+    },
+    category: "third_party",
+    apiFormat: "gemini_native",
+    endpointCandidates: ["https://generativelanguage.googleapis.com"],
+    icon: "gemini",
+    iconColor: "#4285F4",
+  },
   {
     name: "Shengsuanyun",
     nameKey: "providerForm.presets.shengsuanyun",

src/i18n/locales/en.json

@@ -801,6 +801,7 @@
     "modelHint": "💡 Leave blank to use provider's default model",
     "apiHint": "💡 Fill in Claude API compatible service endpoint, avoid trailing slash",
     "apiHintOAI": "💡 Fill in OpenAI Chat Completions compatible service endpoint, avoid trailing slash",
+    "apiHintGeminiNative": "💡 Prefer a Gemini Native base URL such as https://generativelanguage.googleapis.com or https://generativelanguage.googleapis.com/v1beta; the proxy will append models/*:generateContent automatically",
     "codexApiHint": "💡 Fill in service endpoint compatible with OpenAI Response format",
     "fillSupplierName": "Please fill in provider name",
     "fillConfigContent": "Please fill in configuration content",
@@ -823,9 +824,11 @@
     "fullUrlEnabled": "Full URL Mode",
     "fullUrlDisabled": "Mark as Full URL",
     "fullUrlHint": "💡 Enter the full request URL. This mode requires routing to be enabled, and routing will use the URL as-is without appending a path",
+    "fullUrlHintGeminiNative": "💡 In Gemini Native full URL mode, two inputs are supported: 1. official/structured Gemini URLs, which will still be normalized to the requested model and streaming method; 2. opaque custom relay URLs, which will be used mostly as-is with only query parameters appended",
     "apiFormatAnthropic": "Anthropic Messages (Native)",
     "apiFormatOpenAIChat": "OpenAI Chat Completions (Requires routing)",
     "apiFormatOpenAIResponses": "OpenAI Responses API (Requires routing)",
+    "apiFormatGeminiNative": "Gemini Native generateContent (Requires routing)",
     "authField": "Auth Field",
     "authFieldAuthToken": "ANTHROPIC_AUTH_TOKEN (Default)",
     "authFieldApiKey": "ANTHROPIC_API_KEY",

src/i18n/locales/ja.json

@@ -801,6 +801,7 @@
     "modelHint": "💡 空欄ならプロバイダーのデフォルトモデルを使用します",
     "apiHint": "💡 Claude API 互換サービスのエンドポイントを入力してください。末尾にスラッシュを付けないでください",
     "apiHintOAI": "💡 OpenAI Chat Completions 互換サービスのエンドポイントを入力してください。末尾にスラッシュを付けないでください",
+    "apiHintGeminiNative": "💡 Gemini Native では https://generativelanguage.googleapis.com または https://generativelanguage.googleapis.com/v1beta のような base URL を推奨します。プロキシが models/*:generateContent を自動補完します",
     "codexApiHint": "💡 OpenAI Response 互換のサービスエンドポイントを入力してください",
     "fillSupplierName": "プロバイダー名を入力してください",
     "fillConfigContent": "設定内容を入力してください",
@@ -823,9 +824,11 @@
     "fullUrlEnabled": "フル URL モード",
     "fullUrlDisabled": "フル URL として設定",
     "fullUrlHint": "💡 完全なリクエスト URL を入力してください。このモードはルーティングを有効にして使用する必要があり、ルーティングはこの URL をそのまま使用し、パスを追加しません",
+    "fullUrlHintGeminiNative": "💡 Gemini Native のフル URL モードでは 2 種類の入力を扱えます。1. 公式/構造化された Gemini URL は、要求されたモデルやストリーミング方式に合わせて正規化されます。2. カスタム relay の opaque な完全 URL は、主にそのまま使用され、必要なクエリだけ追加されます",
     "apiFormatAnthropic": "Anthropic Messages（ネイティブ）",
     "apiFormatOpenAIChat": "OpenAI Chat Completions（ルーティングが必要）",
     "apiFormatOpenAIResponses": "OpenAI Responses API（ルーティングが必要）",
+    "apiFormatGeminiNative": "Gemini Native generateContent（ルーティングが必要）",
     "authField": "認証フィールド",
     "authFieldAuthToken": "ANTHROPIC_AUTH_TOKEN（デフォルト）",
     "authFieldApiKey": "ANTHROPIC_API_KEY",

src/i18n/locales/zh.json

@@ -802,6 +802,7 @@
     "modelHint": "💡 留空将使用供应商的默认模型",
     "apiHint": "💡 填写兼容 Claude API 的服务端点地址，不要以斜杠结尾",
     "apiHintOAI": "💡 填写兼容 OpenAI Chat Completions 的服务端点地址，不要以斜杠结尾",
+    "apiHintGeminiNative": "💡 建议填写 Gemini Native 的 base URL，例如 https://generativelanguage.googleapis.com 或 https://generativelanguage.googleapis.com/v1beta；代理会自动补全 models/*:generateContent",
     "codexApiHint": "💡 填写兼容 OpenAI Response 格式的服务端点地址",
     "fillSupplierName": "请填写供应商名称",
     "fillConfigContent": "请填写配置内容",
@@ -824,9 +825,11 @@
     "fullUrlEnabled": "完整 URL 模式",
     "fullUrlDisabled": "标记为完整 URL",
     "fullUrlHint": "💡 请填写完整请求 URL，并且必须开启路由后使用；路由将直接使用此 URL，不拼接路径",
+    "fullUrlHintGeminiNative": "💡 Gemini Native 下，完整 URL 模式同时兼容两类地址：1. 官方/标准 Gemini URL，代理会按模型和流式参数自动归一化；2. 自定义 relay 的完整 URL，代理会尽量原样使用，只补查询参数，不再强行追加 models 路径",
     "apiFormatAnthropic": "Anthropic Messages (原生)",
     "apiFormatOpenAIChat": "OpenAI Chat Completions (需开启路由)",
     "apiFormatOpenAIResponses": "OpenAI Responses API (需开启路由)",
+    "apiFormatGeminiNative": "Gemini Native generateContent (需开启路由)",
     "authField": "认证字段",
     "authFieldAuthToken": "ANTHROPIC_AUTH_TOKEN（默认）",
     "authFieldApiKey": "ANTHROPIC_API_KEY",

src/types.ts

@@ -141,7 +141,12 @@ export interface ProviderMeta {
   // - "anthropic": 原生 Anthropic Messages API 格式，直接透传
   // - "openai_chat": OpenAI Chat Completions 格式，需要格式转换
   // - "openai_responses": OpenAI Responses API 格式，需要格式转换
-  apiFormat?: "anthropic" | "openai_chat" | "openai_responses";
+  // - "gemini_native": Gemini Native generateContent API 格式，需要格式转换
+  apiFormat?:
+    | "anthropic"
+    | "openai_chat"
+    | "openai_responses"
+    | "gemini_native";
   // 通用认证绑定
   authBinding?: AuthBinding;
   // Claude 认证字段名
@@ -166,7 +171,12 @@ export type SkillStorageLocation = "cc_switch" | "unified";
 // - "anthropic": 原生 Anthropic Messages API 格式，直接透传
 // - "openai_chat": OpenAI Chat Completions 格式，需要格式转换
 // - "openai_responses": OpenAI Responses API 格式，需要格式转换
-export type ClaudeApiFormat = "anthropic" | "openai_chat" | "openai_responses";
+// - "gemini_native": Gemini Native generateContent API 格式，需要格式转换
+export type ClaudeApiFormat =
+  | "anthropic"
+  | "openai_chat"
+  | "openai_responses"
+  | "gemini_native";
 
 // Claude 认证字段类型
 export type ClaudeApiKeyField = "ANTHROPIC_AUTH_TOKEN" | "ANTHROPIC_API_KEY";