Merge PR #488 and #489

2026-10-08 18:37:46 +08:00 · 2026-05-19 03:16:35 +08:00
parent cd1aa92931 be2e8e594c
commit 69af74b1e0
77 changed files with 4051 additions and 333 deletions
@@ -1256,6 +1256,146 @@ async fn gateway_handles_admin_provider_query_gemini_embedding_model_test() {
    execution_runtime_handle.abort();
 }

+#[tokio::test]
+async fn gateway_handles_admin_provider_query_vertex_gemini_embedding_model_test() {
+    let execution_runtime = Router::new().route(
+        "/v1/execute/sync",
+        any(move |Json(plan): Json<ExecutionPlan>| async move {
+            assert_eq!(plan.provider_id, "provider-vertex-ai");
+            assert_eq!(plan.endpoint_id, "endpoint-vertex-gemini-embedding");
+            assert_eq!(plan.key_id, "key-vertex-gemini-embedding");
+            assert_eq!(plan.client_api_format, "openai:embedding");
+            assert_eq!(plan.provider_api_format, "gemini:embedding");
+            assert_eq!(
+                plan.url,
+                "https://aiplatform.googleapis.com/v1/publishers/google/models/gemini-embedding-2:predict?key=sk-vertex-gemini-embedding"
+            );
+            assert_eq!(plan.model_name.as_deref(), Some("gemini-embedding-2"));
+            assert!(!plan.stream);
+            let body = plan.body.json_body.as_ref().expect("json body");
+            assert!(
+                body.get("model").is_none(),
+                "Vertex predict carries the model in the URL path; the test body must not repeat it"
+            );
+            assert_eq!(
+                body["instances"][0]["content"],
+                json!("This is a test embedding input.")
+            );
+            assert!(body.get("content").is_none());
+            assert!(body.get("requests").is_none());
+            assert!(
+                body.get("stream").is_none(),
+                "gemini embedding provider body must not carry stream"
+            );
+            Json(json!({
+                "request_id": plan.request_id,
+                "candidate_id": plan.candidate_id,
+                "status_code": 200,
+                "headers": {
+                    "content-type": "application/json"
+                },
+                "body": {
+                    "json_body": {
+                        "predictions": [
+                            {
+                                "embeddings": {
+                                    "values": [0.1, 0.2, 0.3]
+                                }
+                            }
+                        ],
+                        "deployedModelId": "gemini-embedding-2"
+                    }
+                },
+                "telemetry": {
+                    "elapsed_ms": 27
+                }
+            }))
+        }),
+    );
+
+    let (execution_runtime_url, execution_runtime_handle) = start_server(execution_runtime).await;
+    let mut provider = sample_provider("provider-vertex-ai", "Vertex AI", 10);
+    provider.provider_type = "vertex_ai".to_string();
+    let mut key = sample_key(
+        "key-vertex-gemini-embedding",
+        "provider-vertex-ai",
+        "gemini:embedding",
+        "sk-vertex-gemini-embedding",
+    );
+    key.allowed_models = Some(json!(["gemini-embedding-2"]));
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        vec![sample_endpoint(
+            "endpoint-vertex-gemini-embedding",
+            "provider-vertex-ai",
+            "gemini:embedding",
+            "https://aiplatform.googleapis.com",
+        )],
+        vec![key],
+    ));
+
+    let gateway = build_router_with_state(
+        build_state_with_execution_runtime_override(execution_runtime_url)
+            .with_data_state_for_tests(GatewayDataState::with_provider_transport_reader_for_tests(
+                provider_catalog_repository,
+                DEVELOPMENT_ENCRYPTION_KEY.to_string(),
+            )),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .post(format!("{gateway_url}/api/admin/provider-query/test-model"))
+        .header(GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .json(&json!({
+            "provider_id": "provider-vertex-ai",
+            "model": "gemini-embedding-2",
+            "api_format": "gemini:embedding",
+            "endpoint_id": "endpoint-vertex-gemini-embedding",
+            "request_body": {
+                "model": "gemini-embedding-2",
+                "input": "This is a test embedding input."
+            }
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    let payload: serde_json::Value = response.json().await.expect("json body should parse");
+    assert_eq!(payload["success"], json!(true));
+    assert_eq!(payload["error"], serde_json::Value::Null);
+    assert_eq!(payload["attempts"][0]["status"], json!("success"));
+    assert_eq!(
+        payload["attempts"][0]["request_body"]["instances"][0]["content"],
+        json!("This is a test embedding input.")
+    );
+    assert_eq!(
+        payload["attempts"][0]["endpoint_product"],
+        json!("Vertex AI")
+    );
+    assert_eq!(
+        payload["attempts"][0]["endpoint_variant"],
+        json!("vertex_native")
+    );
+    assert_eq!(payload["attempts"][0]["endpoint_action"], json!("predict"));
+    assert_eq!(
+        payload["attempts"][0]["endpoint_batch_strategy"],
+        json!("single_instance")
+    );
+    assert!(
+        payload["attempts"][0]["request_body"]
+            .get("model")
+            .is_none(),
+        "attempt debug payload must expose the exact Vertex body without a duplicate model"
+    );
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_handles_admin_provider_query_jina_embedding_model_test() {
    let execution_runtime = Router::new().route(
@@ -1154,6 +1154,14 @@ async fn gateway_handles_admin_system_api_formats_locally_with_trusted_admin_pri
        .expect("formats should be an array");
    assert_eq!(formats[0]["value"], "openai:chat");
    assert_eq!(formats[0]["default_path"], "/v1/chat/completions");
+    let gemini_embedding = formats
+        .iter()
+        .find(|item| item["value"] == "gemini:embedding")
+        .expect("gemini embedding format should exist");
+    assert_eq!(
+        gemini_embedding["default_path"],
+        "/v1beta/models/{model}:{action}"
+    );
    assert!(formats
        .iter()
        .any(|item| item["value"] == "openai:embedding"));
@@ -78,6 +78,147 @@ fn embedding_execution_runtime() -> Router {
    )
 }

+fn gemini_embedding_success_state(
+    execution_runtime_url: String,
+    client_api_format: &str,
+) -> AppState {
+    let mut snapshot = sample_currently_usable_auth_snapshot(
+        "key-gemini-embedding-success",
+        "user-gemini-embedding-success",
+    );
+    snapshot.user_allowed_providers = None;
+    snapshot.api_key_allowed_providers = None;
+    snapshot.user_allowed_api_formats = Some(vec![client_api_format.to_string()]);
+    snapshot.api_key_allowed_api_formats = Some(vec![client_api_format.to_string()]);
+    snapshot.user_allowed_models = Some(vec!["gemini-embedding-2-preview".to_string()]);
+    snapshot.api_key_allowed_models = Some(vec!["gemini-embedding-2-preview".to_string()]);
+    let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+        Some(hash_api_key("sk-gemini-embedding-success")),
+        snapshot,
+    )]));
+    let candidate_repository =
+        Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed(vec![
+            gemini_embedding_candidate_row(),
+        ]));
+    let mut provider = sample_provider("provider-gemini-embedding", "Gemini Embeddings", 1);
+    provider.provider_type = "gemini".to_string();
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        vec![sample_endpoint(
+            "endpoint-gemini-embedding",
+            "provider-gemini-embedding",
+            "gemini:embedding",
+            "https://generativelanguage.googleapis.com/v1beta",
+        )],
+        vec![sample_key(
+            "key-upstream-gemini-embedding",
+            "provider-gemini-embedding",
+            "gemini:embedding",
+            "sk-upstream-gemini-embedding",
+        )],
+    ));
+    let data_state =
+        GatewayDataState::with_provider_catalog_and_minimal_candidate_selection_for_tests(
+            provider_catalog_repository,
+            candidate_repository,
+        )
+        .with_auth_api_key_reader(auth_repository)
+        .with_encryption_key_for_tests(DEVELOPMENT_ENCRYPTION_KEY);
+
+    build_state_with_execution_runtime_override(execution_runtime_url)
+        .with_data_state_for_tests(data_state)
+}
+
+fn vertex_gemini_embedding_success_state(execution_runtime_url: String) -> AppState {
+    let mut snapshot = sample_currently_usable_auth_snapshot(
+        "key-vertex-gemini-embedding-success",
+        "user-vertex-gemini-embedding-success",
+    );
+    snapshot.user_allowed_providers = None;
+    snapshot.api_key_allowed_providers = Some(vec!["openai".to_string(), "vertex_ai".to_string()]);
+    snapshot.user_allowed_api_formats = Some(vec!["openai:embedding".to_string()]);
+    snapshot.api_key_allowed_api_formats = Some(vec!["openai:embedding".to_string()]);
+    snapshot.user_allowed_models = Some(vec!["gemini-embedding-2-preview".to_string()]);
+    snapshot.api_key_allowed_models = Some(vec!["gemini-embedding-2-preview".to_string()]);
+    let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+        Some(hash_api_key("sk-vertex-gemini-embedding-success")),
+        snapshot,
+    )]));
+    let candidate_repository =
+        Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed(vec![
+            vertex_gemini_embedding_candidate_row(),
+        ]));
+    let mut provider = sample_provider("provider-vertex-gemini-embedding", "Vertex AI", 1);
+    provider.provider_type = "vertex_ai".to_string();
+    let mut key = sample_key(
+        "key-upstream-vertex-gemini-embedding",
+        "provider-vertex-gemini-embedding",
+        "gemini:embedding",
+        "sk-upstream-vertex-gemini-embedding",
+    );
+    key.allowed_models = Some(json!(["gemini-embedding-2"]));
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        vec![sample_endpoint(
+            "endpoint-vertex-gemini-embedding",
+            "provider-vertex-gemini-embedding",
+            "gemini:embedding",
+            "https://aiplatform.googleapis.com",
+        )],
+        vec![key],
+    ));
+    let data_state =
+        GatewayDataState::with_provider_catalog_and_minimal_candidate_selection_for_tests(
+            provider_catalog_repository,
+            candidate_repository,
+        )
+        .with_auth_api_key_reader(auth_repository)
+        .with_encryption_key_for_tests(DEVELOPMENT_ENCRYPTION_KEY);
+
+    build_state_with_execution_runtime_override(execution_runtime_url)
+        .with_data_state_for_tests(data_state)
+}
+
+fn gemini_embedding_conversion_execution_runtime() -> Router {
+    Router::new().route(
+        "/v1/execute/sync",
+        any(|Json(plan): Json<ExecutionPlan>| async move {
+            assert_openai_to_gemini_embedding_execution_plan(&plan);
+            Json(gemini_embedding_execution_result(&plan))
+        }),
+    )
+}
+
+fn vertex_gemini_embedding_conversion_execution_runtime() -> Router {
+    Router::new().route(
+        "/v1/execute/sync",
+        any(|Json(plan): Json<ExecutionPlan>| async move {
+            assert_openai_to_vertex_gemini_embedding_execution_plan(&plan);
+            Json(vertex_gemini_embedding_execution_result(&plan))
+        }),
+    )
+}
+
+fn gemini_embedding_batch_conversion_execution_runtime() -> Router {
+    Router::new().route(
+        "/v1/execute/sync",
+        any(|Json(plan): Json<ExecutionPlan>| async move {
+            assert_openai_to_gemini_batch_embedding_execution_plan(&plan);
+            Json(gemini_batch_embedding_execution_result(&plan))
+        }),
+    )
+}
+
+fn gemini_embedding_native_execution_runtime() -> Router {
+    Router::new().route(
+        "/v1/execute/sync",
+        any(|Json(plan): Json<ExecutionPlan>| async move {
+            assert_native_gemini_embedding_execution_plan(&plan);
+            Json(gemini_embedding_execution_result(&plan))
+        }),
+    )
+}
+
 fn embedding_candidate_row() -> StoredMinimalCandidateSelectionRow {
    StoredMinimalCandidateSelectionRow {
        provider_id: "provider-embedding".to_string(),
@@ -112,6 +253,53 @@ fn embedding_candidate_row() -> StoredMinimalCandidateSelectionRow {
    }
 }

+fn gemini_embedding_candidate_row() -> StoredMinimalCandidateSelectionRow {
+    StoredMinimalCandidateSelectionRow {
+        provider_id: "provider-gemini-embedding".to_string(),
+        provider_name: "Gemini Embeddings".to_string(),
+        provider_type: "gemini".to_string(),
+        provider_priority: 1,
+        provider_is_active: true,
+        endpoint_id: "endpoint-gemini-embedding".to_string(),
+        endpoint_api_format: "gemini:embedding".to_string(),
+        endpoint_api_family: Some("gemini".to_string()),
+        endpoint_kind: Some("embedding".to_string()),
+        endpoint_is_active: true,
+        key_id: "key-upstream-gemini-embedding".to_string(),
+        key_name: "default".to_string(),
+        key_auth_type: "api_key".to_string(),
+        key_is_active: true,
+        key_api_formats: Some(vec!["gemini:embedding".to_string()]),
+        key_allowed_models: None,
+        key_capabilities: None,
+        key_internal_priority: 50,
+        key_global_priority_by_format: None,
+        model_id: "model-gemini-embedding-preview".to_string(),
+        global_model_id: "global-gemini-embedding-preview".to_string(),
+        global_model_name: "gemini-embedding-2-preview".to_string(),
+        global_model_mappings: None,
+        global_model_supports_streaming: Some(false),
+        model_provider_model_name: "gemini-embedding-2-preview".to_string(),
+        model_provider_model_mappings: None,
+        model_supports_streaming: Some(false),
+        model_is_active: true,
+        model_is_available: true,
+    }
+}
+
+fn vertex_gemini_embedding_candidate_row() -> StoredMinimalCandidateSelectionRow {
+    let mut row = gemini_embedding_candidate_row();
+    row.provider_id = "provider-vertex-gemini-embedding".to_string();
+    row.provider_name = "Vertex AI".to_string();
+    row.provider_type = "vertex_ai".to_string();
+    row.endpoint_id = "endpoint-vertex-gemini-embedding".to_string();
+    row.key_id = "key-upstream-vertex-gemini-embedding".to_string();
+    row.key_name = "default".to_string();
+    row.key_allowed_models = Some(vec!["gemini-embedding-2".to_string()]);
+    row.model_provider_model_name = "gemini-embedding-2".to_string();
+    row
+}
+
 fn assert_embedding_execution_plan(plan: &ExecutionPlan) {
    assert_eq!(plan.client_api_format, "openai:embedding");
    assert_eq!(plan.provider_api_format, "openai:embedding");
@@ -123,6 +311,103 @@ fn assert_embedding_execution_plan(plan: &ExecutionPlan) {
    assert!(body.get("input").is_some());
 }

+fn assert_openai_to_gemini_embedding_execution_plan(plan: &ExecutionPlan) {
+    assert_eq!(plan.client_api_format, "openai:embedding");
+    assert_eq!(plan.provider_api_format, "gemini:embedding");
+    assert_eq!(plan.method, "POST");
+    assert_eq!(
+        plan.url,
+        "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview:embedContent"
+    );
+    assert_eq!(
+        plan.headers.get("x-goog-api-key").map(String::as_str),
+        Some("sk-upstream-gemini-embedding")
+    );
+    assert_eq!(
+        plan.model_name.as_deref(),
+        Some("gemini-embedding-2-preview")
+    );
+    assert!(!plan.stream);
+    let body = plan.body.json_body.as_ref().expect("json request body");
+    assert_eq!(body["model"], "gemini-embedding-2-preview");
+    assert_eq!(body["content"]["parts"][0]["text"], "hello");
+    assert!(body.get("input").is_none());
+    assert!(body.get("messages").is_none());
+}
+
+fn assert_openai_to_vertex_gemini_embedding_execution_plan(plan: &ExecutionPlan) {
+    assert_eq!(plan.provider_id, "provider-vertex-gemini-embedding");
+    assert_eq!(plan.client_api_format, "openai:embedding");
+    assert_eq!(plan.provider_api_format, "gemini:embedding");
+    assert_eq!(plan.method, "POST");
+    assert_eq!(
+        plan.url,
+        "https://aiplatform.googleapis.com/v1/publishers/google/models/gemini-embedding-2:predict?key=sk-upstream-vertex-gemini-embedding"
+    );
+    assert_eq!(
+        plan.model_name.as_deref(),
+        Some("gemini-embedding-2-preview")
+    );
+    assert!(!plan.stream);
+    let body = plan.body.json_body.as_ref().expect("json request body");
+    assert!(
+        body.get("model").is_none(),
+        "Vertex predict carries the model in the path; the body must not repeat it"
+    );
+    assert_eq!(body["instances"][0]["content"], "hello");
+    assert!(body.get("content").is_none());
+    assert!(body.get("input").is_none());
+    assert!(body.get("messages").is_none());
+}
+
+fn assert_openai_to_gemini_batch_embedding_execution_plan(plan: &ExecutionPlan) {
+    assert_eq!(plan.client_api_format, "openai:embedding");
+    assert_eq!(plan.provider_api_format, "gemini:embedding");
+    assert_eq!(plan.method, "POST");
+    assert_eq!(
+        plan.url,
+        "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview:batchEmbedContents"
+    );
+    assert_eq!(
+        plan.headers.get("x-goog-api-key").map(String::as_str),
+        Some("sk-upstream-gemini-embedding")
+    );
+    assert!(!plan.stream);
+    let body = plan.body.json_body.as_ref().expect("json request body");
+    assert!(body.get("model").is_none());
+    let requests = body["requests"].as_array().expect("batch requests");
+    assert_eq!(requests.len(), 2);
+    assert_eq!(requests[0]["model"], "models/gemini-embedding-2-preview");
+    assert_eq!(requests[0]["content"]["parts"][0]["text"], "hello");
+    assert_eq!(requests[1]["model"], "models/gemini-embedding-2-preview");
+    assert_eq!(requests[1]["content"]["parts"][0]["text"], "world");
+    assert!(body.get("input").is_none());
+    assert!(body.get("messages").is_none());
+}
+
+fn assert_native_gemini_embedding_execution_plan(plan: &ExecutionPlan) {
+    assert_eq!(plan.client_api_format, "gemini:embedding");
+    assert_eq!(plan.provider_api_format, "gemini:embedding");
+    assert_eq!(plan.method, "POST");
+    assert_eq!(
+        plan.url,
+        "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview:embedContent"
+    );
+    assert_eq!(
+        plan.headers.get("x-goog-api-key").map(String::as_str),
+        Some("sk-upstream-gemini-embedding")
+    );
+    assert_eq!(
+        plan.model_name.as_deref(),
+        Some("gemini-embedding-2-preview")
+    );
+    assert!(!plan.stream);
+    let body = plan.body.json_body.as_ref().expect("json request body");
+    assert_eq!(body["content"]["parts"][0]["text"], "hello");
+    assert!(body.get("input").is_none());
+    assert!(body.get("messages").is_none());
+}
+
 fn embedding_execution_result(plan: &ExecutionPlan) -> ExecutionResult {
    ExecutionResult {
        request_id: plan.request_id.clone(),
@@ -145,6 +430,79 @@ fn embedding_execution_result(plan: &ExecutionPlan) -> ExecutionResult {
    }
 }

+fn gemini_embedding_execution_result(plan: &ExecutionPlan) -> ExecutionResult {
+    ExecutionResult {
+        request_id: plan.request_id.clone(),
+        candidate_id: plan.candidate_id.clone(),
+        status_code: 200,
+        headers: BTreeMap::from([("content-type".to_string(), "application/json".to_string())]),
+        body: Some(ResponseBody {
+            json_body: Some(json!({
+                "model": "gemini-embedding-2-preview",
+                "embedding": {
+                    "values": [0.1, 0.2, 0.3]
+                },
+                "usageMetadata": {
+                    "promptTokenCount": 4,
+                    "totalTokenCount": 4
+                }
+            })),
+            body_bytes_b64: None,
+        }),
+        telemetry: None,
+        error: None,
+    }
+}
+
+fn vertex_gemini_embedding_execution_result(plan: &ExecutionPlan) -> ExecutionResult {
+    ExecutionResult {
+        request_id: plan.request_id.clone(),
+        candidate_id: plan.candidate_id.clone(),
+        status_code: 200,
+        headers: BTreeMap::from([("content-type".to_string(), "application/json".to_string())]),
+        body: Some(ResponseBody {
+            json_body: Some(json!({
+                "predictions": [
+                    {
+                        "embeddings": {
+                            "values": [0.1, 0.2, 0.3]
+                        }
+                    }
+                ],
+                "deployedModelId": "gemini-embedding-2"
+            })),
+            body_bytes_b64: None,
+        }),
+        telemetry: None,
+        error: None,
+    }
+}
+
+fn gemini_batch_embedding_execution_result(plan: &ExecutionPlan) -> ExecutionResult {
+    ExecutionResult {
+        request_id: plan.request_id.clone(),
+        candidate_id: plan.candidate_id.clone(),
+        status_code: 200,
+        headers: BTreeMap::from([("content-type".to_string(), "application/json".to_string())]),
+        body: Some(ResponseBody {
+            json_body: Some(json!({
+                "model": "gemini-embedding-2-preview",
+                "embeddings": [
+                    {"values": [0.1, 0.2, 0.3]},
+                    {"values": [0.4, 0.5, 0.6]}
+                ],
+                "usageMetadata": {
+                    "promptTokenCount": 8,
+                    "totalTokenCount": 8
+                }
+            })),
+            body_bytes_b64: None,
+        }),
+        telemetry: None,
+        error: None,
+    }
+}
+
 #[tokio::test]
 async fn embeddings_route_accepts_openai_payload() {
    let (execution_runtime_url, execution_runtime_handle) =
@@ -215,6 +573,201 @@ async fn embeddings_route_accepts_openai_payload() {
    execution_runtime_handle.abort();
 }

+#[tokio::test]
+async fn embeddings_route_converts_openai_payload_to_gemini_embedding_provider() {
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(gemini_embedding_conversion_execution_runtime()).await;
+    let gateway = build_router_with_state(gemini_embedding_success_state(
+        execution_runtime_url,
+        "openai:embedding",
+    ));
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .post(format!("{gateway_url}/v1/embeddings"))
+        .header(
+            http::header::AUTHORIZATION,
+            "Bearer sk-gemini-embedding-success",
+        )
+        .json(&json!({
+            "model": "gemini-embedding-2-preview",
+            "input": "hello"
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_ENDPOINT_SIGNATURE_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("openai:embedding")
+    );
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_EXECUTION_RUNTIME_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("true")
+    );
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["object"], "list");
+    assert_eq!(payload["model"], "gemini-embedding-2-preview");
+    assert_eq!(payload["data"][0]["object"], "embedding");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["usage"]["prompt_tokens"], json!(4));
+    assert_eq!(payload["usage"]["total_tokens"], json!(4));
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn embeddings_route_converts_openai_payload_to_vertex_gemini_embedding_provider() {
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(vertex_gemini_embedding_conversion_execution_runtime()).await;
+    let gateway =
+        build_router_with_state(vertex_gemini_embedding_success_state(execution_runtime_url));
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .post(format!("{gateway_url}/v1/embeddings"))
+        .header(
+            http::header::AUTHORIZATION,
+            "Bearer sk-vertex-gemini-embedding-success",
+        )
+        .json(&json!({
+            "model": "gemini-embedding-2-preview",
+            "input": "hello"
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    let endpoint_signature = response
+        .headers()
+        .get(CONTROL_ENDPOINT_SIGNATURE_HEADER)
+        .and_then(|value| value.to_str().ok())
+        .map(str::to_string);
+    let status = response.status();
+    let body_text = response.text().await.expect("body should read");
+    assert_eq!(
+        status,
+        StatusCode::OK,
+        "unexpected response body: {body_text}"
+    );
+    assert_eq!(endpoint_signature.as_deref(), Some("openai:embedding"));
+    let payload: serde_json::Value = serde_json::from_str(&body_text).expect("body should parse");
+    assert_eq!(payload["object"], "list");
+    assert_eq!(payload["model"], "gemini-embedding-2");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn embeddings_route_converts_openai_batch_payload_to_gemini_batch_endpoint() {
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(gemini_embedding_batch_conversion_execution_runtime()).await;
+    let gateway = build_router_with_state(gemini_embedding_success_state(
+        execution_runtime_url,
+        "openai:embedding",
+    ));
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .post(format!("{gateway_url}/v1/embeddings"))
+        .header(
+            http::header::AUTHORIZATION,
+            "Bearer sk-gemini-embedding-success",
+        )
+        .json(&json!({
+            "model": "gemini-embedding-2-preview",
+            "input": ["hello", "world"]
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_ENDPOINT_SIGNATURE_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("openai:embedding")
+    );
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["object"], "list");
+    assert_eq!(payload["data"].as_array().map(Vec::len), Some(2));
+    assert_eq!(payload["data"][0]["index"], json!(0));
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["data"][1]["index"], json!(1));
+    assert_eq!(payload["data"][1]["embedding"], json!([0.4, 0.5, 0.6]));
+    assert_eq!(payload["usage"]["prompt_tokens"], json!(8));
+    assert_eq!(payload["usage"]["total_tokens"], json!(8));
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn gemini_embed_content_route_uses_native_gemini_embedding_provider() {
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(gemini_embedding_native_execution_runtime()).await;
+    let gateway = build_router_with_state(gemini_embedding_success_state(
+        execution_runtime_url,
+        "gemini:embedding",
+    ));
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let response = reqwest::Client::new()
+        .post(format!(
+            "{gateway_url}/v1beta/models/gemini-embedding-2-preview:embedContent"
+        ))
+        .header("x-goog-api-key", "sk-gemini-embedding-success")
+        .json(&json!({
+            "content": {
+                "parts": [{"text": "hello"}]
+            }
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_ROUTE_FAMILY_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("gemini")
+    );
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_ROUTE_KIND_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("embedding")
+    );
+    assert_eq!(
+        response
+            .headers()
+            .get(CONTROL_ENDPOINT_SIGNATURE_HEADER)
+            .and_then(|value| value.to_str().ok()),
+        Some("gemini:embedding")
+    );
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["embedding"]["values"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["model"], "gemini-embedding-2-preview");
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
 #[tokio::test]
 async fn embeddings_route_accepts_all_canonical_input_shapes() {
    let (execution_runtime_url, execution_runtime_handle) =