Merge remote-tracking branch 'origin/pr/593'

apps/aether-gateway/src/ai_serving/planner/passthrough/provider/family/request.rs

@@ -56,6 +56,7 @@ pub(crate) fn resolve_same_format_provider_transport_unsupported_reason_for_trac
             "jina:embedding" => "jina:embedding",
             "jina:rerank" => "jina:rerank",
             "doubao:embedding" => "doubao:embedding",
+            "aliyun:multimodal_embedding" => "aliyun:multimodal_embedding",
             _ => return Some("transport_api_format_unsupported"),
         };
     let behavior = policy::classify_same_format_provider_request_behavior(

apps/aether-gateway/src/api/ai/aliyun.rs

@@ -0,0 +1,15 @@
+pub(crate) fn normalized_signature(api_format: &str) -> Option<&'static str> {
+    match crate::ai_serving::normalize_api_format_alias(api_format).as_str() {
+        "aliyun:multimodal_embedding" => Some("aliyun:multimodal_embedding"),
+        _ => None,
+    }
+}
+
+pub(crate) fn local_path(api_format: &str) -> Option<&'static str> {
+    match crate::ai_serving::normalize_api_format_alias(api_format).as_str() {
+        "aliyun:multimodal_embedding" => {
+            Some("/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding")
+        }
+        _ => None,
+    }
+}

apps/aether-gateway/src/api/ai/mod.rs

@@ -1,3 +1,4 @@
+mod aliyun;
 mod claude;
 mod doubao;
 mod gemini;

apps/aether-gateway/src/api/ai/registry.rs

@@ -1,7 +1,7 @@
 use axum::routing::{any, post};
 use axum::Router;
 
-use super::{claude, doubao, gemini, jina, openai};
+use super::{aliyun, claude, doubao, gemini, jina, openai};
 use crate::{handlers::proxy::proxy_request, state::AppState};
 
 // Router registration patterns live here so AI public ingress has a single mount registry.
@@ -56,6 +56,7 @@ pub(crate) fn public_api_format_local_path(api_format: &str) -> &'static str {
         .or_else(|| gemini::local_path(&normalized))
         .or_else(|| jina::local_path(&normalized))
         .or_else(|| doubao::local_path(&normalized))
+        .or_else(|| aliyun::local_path(&normalized))
         .unwrap_or("/")
 }
 
@@ -66,6 +67,7 @@ pub(crate) fn normalize_admin_endpoint_signature(api_format: &str) -> Option<&'s
         .or_else(|| gemini::normalized_signature(&normalized))
         .or_else(|| jina::normalized_signature(&normalized))
         .or_else(|| doubao::normalized_signature(&normalized))
+        .or_else(|| aliyun::normalized_signature(&normalized))
 }
 
 pub(crate) fn admin_endpoint_signature_parts(
@@ -101,6 +103,12 @@ mod tests {
             ),
             ("jina:embedding", "jina", "embedding", "/v1/embeddings"),
             ("doubao:embedding", "doubao", "embedding", "/v1/embeddings"),
+            (
+                "aliyun:multimodal_embedding",
+                "aliyun",
+                "multimodal_embedding",
+                "/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding",
+            ),
             ("openai:rerank", "openai", "rerank", "/v1/rerank"),
             ("jina:rerank", "jina", "rerank", "/v1/rerank"),
         ] {

apps/aether-gateway/src/handlers/admin/model/global/providers.rs

@@ -13,6 +13,7 @@ const EMBEDDING_API_FORMATS: &[&str] = &[
     "jina:embedding",
     "gemini:embedding",
     "doubao:embedding",
+    "aliyun:multimodal_embedding",
 ];
 
 fn json_value_contains_string(value: &serde_json::Value, expected: &str) -> bool {

apps/aether-gateway/src/handlers/admin/model/payloads.rs

@@ -6,6 +6,7 @@ const EMBEDDING_API_FORMATS: &[&str] = &[
     "jina:embedding",
     "gemini:embedding",
     "doubao:embedding",
+    "aliyun:multimodal_embedding",
 ];
 
 pub(crate) fn model_tiered_pricing_first_tier_value(

apps/aether-gateway/src/handlers/admin/observability/monitoring/cache_affinity.rs

@@ -94,7 +94,7 @@ fn split_admin_monitoring_api_format_and_model(
 fn is_known_admin_monitoring_api_format_family(value: &str) -> bool {
     matches!(
         value.trim().to_ascii_lowercase().as_str(),
-        "openai" | "claude" | "gemini" | "jina" | "doubao"
+        "openai" | "claude" | "gemini" | "jina" | "doubao" | "aliyun"
     )
 }
 
@@ -116,6 +116,7 @@ fn is_known_admin_monitoring_api_format(value: &str) -> bool {
             | "jina:embedding"
             | "jina:rerank"
             | "doubao:embedding"
+            | "aliyun:multimodal_embedding"
     )
 }
 

apps/aether-gateway/src/handlers/admin/provider/query/models/model_test.rs

@@ -597,6 +597,22 @@ fn provider_query_build_test_request_body_for_api_format(
     let message = provider_query_extract_message(payload)
         .unwrap_or_else(|| DEFAULT_PROVIDER_QUERY_TEST_MESSAGE.to_string());
     match client_api_format.as_str() {
+        "openai:embedding" => json!({
+            "model": model,
+            "input": message,
+        }),
+        "openai:rerank" => json!({
+            "model": model,
+            "query": message,
+            "documents": [
+                "apple",
+                "banana",
+                "fruit",
+                "vegetable"
+            ],
+            "return_documents": true,
+            "top_n": 4,
+        }),
         "openai:responses" | "openai:responses:compact" => json!({
             "model": model,
             "input": message,
@@ -649,6 +665,21 @@ fn provider_query_insert_default_test_conversation(
     let message = provider_query_extract_message(payload)
         .unwrap_or_else(|| DEFAULT_PROVIDER_QUERY_TEST_MESSAGE.to_string());
     match client_api_format {
+        "openai:embedding" => {
+            object.insert("input".to_string(), Value::String(message));
+        }
+        "openai:rerank" => {
+            object.insert("query".to_string(), Value::String(message));
+            object
+                .entry("documents".to_string())
+                .or_insert_with(|| json!(["apple", "banana", "fruit", "vegetable"]));
+            object
+                .entry("return_documents".to_string())
+                .or_insert(Value::Bool(true));
+            object
+                .entry("top_n".to_string())
+                .or_insert_with(|| Value::from(4_u64));
+        }
         "openai:responses" | "openai:responses:compact" => {
             object.insert("input".to_string(), Value::String(message));
         }
@@ -2920,8 +2951,13 @@ async fn provider_query_execute_standard_test_candidate(
             );
             provider_request_body
         }
-        "openai:embedding" | "gemini:embedding" | "jina:embedding" | "doubao:embedding"
-        | "openai:rerank" | "jina:rerank" => {
+        "openai:embedding"
+        | "gemini:embedding"
+        | "jina:embedding"
+        | "doubao:embedding"
+        | "aliyun:multimodal_embedding"
+        | "openai:rerank"
+        | "jina:rerank" => {
             let Some(mut provider_request_body) =
                 crate::ai_serving::build_standard_request_body_with_model_directives_and_request_headers(
                     &request_body,
@@ -3051,6 +3087,7 @@ async fn provider_query_execute_standard_test_candidate(
             | "gemini:embedding"
             | "jina:embedding"
             | "doubao:embedding"
+            | "aliyun:multimodal_embedding"
             | "openai:rerank"
             | "jina:rerank" => state.resolve_local_oauth_header_auth(&transport).await?,
             _ => None,
@@ -3062,6 +3099,7 @@ async fn provider_query_execute_standard_test_candidate(
         | "openai:embedding"
         | "jina:embedding"
         | "doubao:embedding"
+        | "aliyun:multimodal_embedding"
         | "openai:rerank"
         | "jina:rerank" => {
             crate::provider_transport::auth::resolve_local_openai_bearer_auth(&transport)

apps/aether-gateway/src/handlers/admin/provider/query/models/model_test/adapter.rs

@@ -74,6 +74,7 @@ pub(super) fn provider_query_standard_test_unsupported_reason(
         | "openai:embedding"
         | "jina:embedding"
         | "doubao:embedding"
+        | "aliyun:multimodal_embedding"
         | "openai:rerank"
         | "jina:rerank" => {
             crate::provider_transport::policy::local_standard_transport_unsupported_reason_with_network(
@@ -253,6 +254,7 @@ pub(super) fn provider_query_test_adapter_for_provider_api_format(
             | "gemini:embedding"
             | "jina:embedding"
             | "doubao:embedding"
+            | "aliyun:multimodal_embedding"
             | "openai:rerank"
             | "jina:rerank"
     ) {
@@ -352,6 +354,7 @@ pub(super) fn provider_query_transport_supports_model_test_execution(
         | "openai:embedding"
         | "jina:embedding"
         | "doubao:embedding"
+        | "aliyun:multimodal_embedding"
         | "openai:rerank"
         | "jina:rerank" => {
             crate::provider_transport::policy::supports_local_standard_transport_with_network(

apps/aether-gateway/src/handlers/admin/provider/query/models/model_test/summary.rs

@@ -138,6 +138,12 @@ fn provider_query_endpoint_route_payload(
             "embeddings",
             "openai_batch",
         ),
+        "aliyun:multimodal_embedding" => (
+            "Aliyun DashScope",
+            "dashscope_native",
+            "multimodal-embedding",
+            "dashscope_contents",
+        ),
         "openai:chat" if is_vertex && is_openai_compat => (
             "Vertex AI OpenAI-compatible",
             "openai_compatible",

apps/aether-gateway/src/handlers/admin/provider/query/models/model_test/tests.rs

@@ -470,6 +470,26 @@ fn provider_query_compact_test_request_body_defaults_to_responses_input() {
     assert!(body.get("messages").is_none());
 }
 
+#[test]
+fn provider_query_embedding_test_request_body_defaults_to_embedding_input() {
+    let payload = json!({"message": "hello from embedding"});
+
+    let client_api_format =
+        provider_query_standard_test_client_api_format("aliyun:multimodal_embedding");
+    let body = provider_query_build_test_request_body_for_api_format(
+        &payload,
+        "qwen3-vl-embedding",
+        "/api/admin/provider-query/test-model",
+        client_api_format,
+    );
+
+    assert_eq!(client_api_format, "openai:embedding");
+    assert_eq!(body["model"], json!("qwen3-vl-embedding"));
+    assert_eq!(body["input"], json!("hello from embedding"));
+    assert!(body.get("messages").is_none());
+    assert!(body.get("stream").is_none());
+}
+
 #[test]
 fn provider_query_compact_test_request_body_promotes_prompt_to_input() {
     let payload = json!({
@@ -658,6 +678,13 @@ fn provider_query_test_adapter_routes_fixed_provider_endpoint_types() {
         provider_query_test_adapter_for_provider_api_format("custom", "gemini:embedding"),
         Some(ProviderQueryTestAdapter::Standard)
     );
+    assert_eq!(
+        provider_query_test_adapter_for_provider_api_format(
+            "aliyun",
+            "aliyun:multimodal_embedding"
+        ),
+        Some(ProviderQueryTestAdapter::Standard)
+    );
     assert_eq!(
         provider_query_test_adapter_for_provider_api_format("jina", "jina:rerank"),
         Some(ProviderQueryTestAdapter::Standard)

apps/aether-gateway/src/handlers/public/ai_public.rs

@@ -522,12 +522,45 @@ fn embedding_array_input_is_non_empty(items: &[Value]) -> bool {
             item.as_array()
                 .is_some_and(|items| embedding_token_array_is_non_empty(items))
         })
+        || items.iter().all(embedding_multimodal_content_is_non_empty)
 }
 
 fn embedding_token_array_is_non_empty(items: &[Value]) -> bool {
     !items.is_empty() && items.iter().all(|item| item.as_u64().is_some())
 }
 
+fn embedding_multimodal_content_is_non_empty(value: &Value) -> bool {
+    let Some(object) = value.as_object() else {
+        return false;
+    };
+    let valid_text = object
+        .get("text")
+        .map(|value| value.as_str().is_some_and(|text| !text.trim().is_empty()));
+    let valid_image = object
+        .get("image")
+        .map(|value| value.as_str().is_some_and(|image| !image.trim().is_empty()));
+    let valid_video = object
+        .get("video")
+        .map(|value| value.as_str().is_some_and(|video| !video.trim().is_empty()));
+    let valid_multi_images = object.get("multi_images").map(|value| {
+        value.as_array().is_some_and(|items| {
+            !items.is_empty()
+                && items
+                    .iter()
+                    .all(|item| item.as_str().is_some_and(|image| !image.trim().is_empty()))
+        })
+    });
+
+    [valid_text, valid_image, valid_video, valid_multi_images]
+        .into_iter()
+        .flatten()
+        .all(|valid| valid)
+        && [valid_text, valid_image, valid_video, valid_multi_images]
+            .into_iter()
+            .flatten()
+            .any(|valid| valid)
+}
+
 fn image_request_count(value: &Value) -> Option<u64> {
     value
         .as_u64()

apps/aether-gateway/src/handlers/public/support/models/shared.rs

@@ -25,6 +25,7 @@ pub(crate) fn models_api_format(request_context: &GatewayPublicRequestContext) -
         "jina:embedding" => Some("jina:embedding"),
         "jina:rerank" => Some("jina:rerank"),
         "doubao:embedding" => Some("doubao:embedding"),
+        "aliyun:multimodal_embedding" => Some("aliyun:multimodal_embedding"),
         _ => None,
     }
 }
@@ -43,6 +44,7 @@ const MODELS_EMBEDDING_QUERY_API_FORMATS: &[&str] = &[
     "jina:embedding",
     "gemini:embedding",
     "doubao:embedding",
+    "aliyun:multimodal_embedding",
 ];
 const MODELS_RERANK_QUERY_API_FORMATS: &[&str] = &["openai:rerank", "jina:rerank"];
 
@@ -54,9 +56,11 @@ pub(super) fn models_query_api_formats(api_format: &str) -> &'static [&'static s
         | "claude:messages"
         | "gemini:generate_content" => MODELS_CROSS_FORMAT_QUERY_API_FORMATS,
         "openai:image" => &["openai:image"],
-        "openai:embedding" | "jina:embedding" | "gemini:embedding" | "doubao:embedding" => {
-            MODELS_EMBEDDING_QUERY_API_FORMATS
-        }
+        "openai:embedding"
+        | "jina:embedding"
+        | "gemini:embedding"
+        | "doubao:embedding"
+        | "aliyun:multimodal_embedding" => MODELS_EMBEDDING_QUERY_API_FORMATS,
         "openai:rerank" | "jina:rerank" => MODELS_RERANK_QUERY_API_FORMATS,
         _ => &[],
     }

apps/aether-gateway/src/tests/control/admin/system.rs

@@ -1452,6 +1452,14 @@ async fn gateway_handles_admin_system_api_formats_locally_with_trusted_admin_pri
     assert!(formats.iter().any(|item| item["value"] == "jina:embedding"));
     assert!(formats.iter().any(|item| item["value"] == "jina:rerank"));
     assert!(formats.iter().any(|item| item["value"] == "gemini:video"));
+    let aliyun_embedding = formats
+        .iter()
+        .find(|item| item["value"] == "aliyun:multimodal_embedding")
+        .expect("aliyun multimodal embedding format should exist");
+    assert_eq!(
+        aliyun_embedding["default_path"],
+        "/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding"
+    );
     assert_eq!(*upstream_hits.lock().expect("mutex should lock"), 0);
 
     gateway_handle.abort();

apps/aether-gateway/src/tests/control/proxy/embeddings.rs

@@ -179,6 +179,129 @@ fn vertex_gemini_embedding_success_state(execution_runtime_url: String) -> AppSt
         .with_data_state_for_tests(data_state)
 }
 
+fn aliyun_embedding_success_state(execution_runtime_url: String) -> AppState {
+    let mut snapshot = sample_currently_usable_auth_snapshot(
+        "key-aliyun-embedding-success",
+        "user-aliyun-embedding-success",
+    );
+    snapshot.user_allowed_providers = None;
+    snapshot.api_key_allowed_providers = None;
+    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!["qwen3-vl-embedding".to_string()]);
+    snapshot.api_key_allowed_models = Some(vec!["qwen3-vl-embedding".to_string()]);
+    let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+        Some(hash_api_key("sk-aliyun-embedding-success")),
+        snapshot,
+    )]));
+    let candidate_repository =
+        Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed(vec![
+            aliyun_embedding_candidate_row(),
+        ]));
+    let mut provider = sample_provider("provider-aliyun-embedding", "Aliyun DashScope", 1);
+    provider.provider_type = "aliyun".to_string();
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        vec![sample_endpoint(
+            "endpoint-aliyun-embedding",
+            "provider-aliyun-embedding",
+            "aliyun:multimodal_embedding",
+            "https://dashscope.aliyuncs.com",
+        )],
+        vec![sample_key(
+            "key-upstream-aliyun-embedding",
+            "provider-aliyun-embedding",
+            "aliyun:multimodal_embedding",
+            "sk-upstream-aliyun-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 mixed_embedding_success_state(execution_runtime_url: String) -> AppState {
+    let mut snapshot = sample_currently_usable_auth_snapshot(
+        "key-mixed-embedding-success",
+        "user-mixed-embedding-success",
+    );
+    snapshot.user_allowed_providers = None;
+    snapshot.api_key_allowed_providers = None;
+    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!["qwen3-vl-embedding".to_string()]);
+    snapshot.api_key_allowed_models = Some(vec!["qwen3-vl-embedding".to_string()]);
+    let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::seed(vec![(
+        Some(hash_api_key("sk-mixed-embedding-success")),
+        snapshot,
+    )]));
+
+    let mut openai_candidate = embedding_candidate_row();
+    openai_candidate.model_id = "model-openai-qwen-vl-embedding".to_string();
+    openai_candidate.global_model_id = "global-qwen3-vl-embedding".to_string();
+    openai_candidate.global_model_name = "qwen3-vl-embedding".to_string();
+    openai_candidate.model_provider_model_name = "openai-qwen-fallback".to_string();
+    let candidate_repository =
+        Arc::new(InMemoryMinimalCandidateSelectionReadRepository::seed(vec![
+            openai_candidate,
+            aliyun_embedding_candidate_row(),
+        ]));
+
+    let mut aliyun_provider = sample_provider("provider-aliyun-embedding", "Aliyun DashScope", 1);
+    aliyun_provider.provider_type = "aliyun".to_string();
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![
+            sample_provider("provider-embedding", "OpenAI Embeddings", 1),
+            aliyun_provider,
+        ],
+        vec![
+            sample_endpoint(
+                "endpoint-embedding",
+                "provider-embedding",
+                "openai:embedding",
+                "https://api.openai.example",
+            ),
+            sample_endpoint(
+                "endpoint-aliyun-embedding",
+                "provider-aliyun-embedding",
+                "aliyun:multimodal_embedding",
+                "https://dashscope.aliyuncs.com",
+            ),
+        ],
+        vec![
+            sample_key(
+                "key-upstream-embedding",
+                "provider-embedding",
+                "openai:embedding",
+                "sk-upstream-embedding",
+            ),
+            sample_key(
+                "key-upstream-aliyun-embedding",
+                "provider-aliyun-embedding",
+                "aliyun:multimodal_embedding",
+                "sk-upstream-aliyun-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 gemini_embedding_conversion_execution_runtime() -> Router {
     Router::new().route(
         "/v1/execute/sync",
@@ -189,6 +312,29 @@ fn gemini_embedding_conversion_execution_runtime() -> Router {
     )
 }
 
+fn aliyun_embedding_conversion_execution_runtime(
+    expected_contents: serde_json::Value,
+    expected_parameters: Option<serde_json::Value>,
+) -> Router {
+    let expected_contents = Arc::new(expected_contents);
+    let expected_parameters = Arc::new(expected_parameters);
+    Router::new().route(
+        "/v1/execute/sync",
+        any(move |Json(plan): Json<ExecutionPlan>| {
+            let expected_contents = Arc::clone(&expected_contents);
+            let expected_parameters = Arc::clone(&expected_parameters);
+            async move {
+                assert_openai_to_aliyun_embedding_execution_plan(
+                    &plan,
+                    &expected_contents,
+                    expected_parameters.as_ref().as_ref(),
+                );
+                Json(aliyun_embedding_execution_result(&plan))
+            }
+        }),
+    )
+}
+
 fn vertex_gemini_embedding_conversion_execution_runtime() -> Router {
     Router::new().route(
         "/v1/execute/sync",
@@ -300,6 +446,40 @@ fn vertex_gemini_embedding_candidate_row() -> StoredMinimalCandidateSelectionRow
     row
 }
 
+fn aliyun_embedding_candidate_row() -> StoredMinimalCandidateSelectionRow {
+    StoredMinimalCandidateSelectionRow {
+        provider_id: "provider-aliyun-embedding".to_string(),
+        provider_name: "Aliyun DashScope".to_string(),
+        provider_type: "aliyun".to_string(),
+        provider_priority: 1,
+        provider_is_active: true,
+        endpoint_id: "endpoint-aliyun-embedding".to_string(),
+        endpoint_api_format: "aliyun:multimodal_embedding".to_string(),
+        endpoint_api_family: Some("aliyun".to_string()),
+        endpoint_kind: Some("multimodal_embedding".to_string()),
+        endpoint_is_active: true,
+        key_id: "key-upstream-aliyun-embedding".to_string(),
+        key_name: "default".to_string(),
+        key_auth_type: "api_key".to_string(),
+        key_is_active: true,
+        key_api_formats: Some(vec!["aliyun:multimodal_embedding".to_string()]),
+        key_allowed_models: None,
+        key_capabilities: None,
+        key_internal_priority: 50,
+        key_global_priority_by_format: None,
+        model_id: "model-qwen3-vl-embedding".to_string(),
+        global_model_id: "global-qwen3-vl-embedding".to_string(),
+        global_model_name: "qwen3-vl-embedding".to_string(),
+        global_model_mappings: None,
+        global_model_supports_streaming: Some(false),
+        model_provider_model_name: "qwen3-vl-embedding".to_string(),
+        model_provider_model_mappings: None,
+        model_supports_streaming: Some(false),
+        model_is_active: true,
+        model_is_available: true,
+    }
+}
+
 fn assert_embedding_execution_plan(plan: &ExecutionPlan) {
     assert_eq!(plan.client_api_format, "openai:embedding");
     assert_eq!(plan.provider_api_format, "openai:embedding");
@@ -311,6 +491,34 @@ fn assert_embedding_execution_plan(plan: &ExecutionPlan) {
     assert!(body.get("input").is_some());
 }
 
+fn assert_openai_to_aliyun_embedding_execution_plan(
+    plan: &ExecutionPlan,
+    expected_contents: &serde_json::Value,
+    expected_parameters: Option<&serde_json::Value>,
+) {
+    assert_eq!(plan.client_api_format, "openai:embedding");
+    assert_eq!(plan.provider_api_format, "aliyun:multimodal_embedding");
+    assert_eq!(plan.method, "POST");
+    assert_eq!(
+        plan.url,
+        "https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding"
+    );
+    assert_eq!(
+        plan.headers.get("authorization").map(String::as_str),
+        Some("Bearer sk-upstream-aliyun-embedding")
+    );
+    assert_eq!(plan.model_name.as_deref(), Some("qwen3-vl-embedding"));
+    assert!(!plan.stream);
+    let body = plan.body.json_body.as_ref().expect("json request body");
+    assert_eq!(body["model"], "qwen3-vl-embedding");
+    assert_eq!(&body["input"]["contents"], expected_contents);
+    match expected_parameters {
+        Some(expected) => assert_eq!(&body["parameters"], expected),
+        None => assert!(body.get("parameters").is_none()),
+    }
+    assert!(body.get("messages").is_none());
+}
+
 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");
@@ -503,6 +711,41 @@ fn gemini_batch_embedding_execution_result(plan: &ExecutionPlan) -> ExecutionRes
     }
 }
 
+fn aliyun_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!({
+                "output": {
+                    "embeddings": [
+                        {
+                            "index": 0,
+                            "embedding": [0.1, 0.2, 0.3],
+                            "type": "fusion"
+                        }
+                    ]
+                },
+                "usage": {
+                    "input_tokens": 432,
+                    "input_tokens_details": {
+                        "image_tokens": 402,
+                        "text_tokens": 30
+                    },
+                    "output_tokens": 1,
+                    "total_tokens": 433
+                },
+                "request_id": "aliyun-request-1"
+            })),
+            body_bytes_b64: None,
+        }),
+        telemetry: None,
+        error: None,
+    }
+}
+
 #[tokio::test]
 async fn embeddings_route_accepts_openai_payload() {
     let (execution_runtime_url, execution_runtime_handle) =
@@ -714,6 +957,183 @@ async fn embeddings_route_converts_openai_batch_payload_to_gemini_batch_endpoint
     execution_runtime_handle.abort();
 }
 
+#[tokio::test]
+async fn embeddings_route_converts_text_payload_to_aliyun_embedding_provider() {
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(aliyun_embedding_conversion_execution_runtime(
+            json!([{ "text": "hello" }]),
+            Some(json!({ "dimension": 1024 })),
+        ))
+        .await;
+    let gateway = build_router_with_state(aliyun_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-aliyun-embedding-success",
+        )
+        .json(&json!({
+            "model": "qwen3-vl-embedding",
+            "input": "hello",
+            "dimensions": 1024
+        }))
+        .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["request_id"], "aliyun-request-1");
+    assert_eq!(payload["model"], "qwen3-vl-embedding");
+    assert_eq!(payload["data"][0]["object"], "embedding");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["data"][0]["type"], "fusion");
+    assert_eq!(payload["usage"]["prompt_tokens"], json!(432));
+    assert_eq!(payload["usage"]["completion_tokens"], json!(1));
+    assert_eq!(payload["usage"]["total_tokens"], json!(433));
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn embeddings_route_converts_multimodal_payload_to_aliyun_embedding_provider() {
+    let expected_contents = json!([
+        { "text": "white running shoes" },
+        { "image": "https://example.com/shoe.png" },
+        { "multi_images": ["https://example.com/a.png", "https://example.com/b.png"] }
+    ]);
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(aliyun_embedding_conversion_execution_runtime(
+            expected_contents.clone(),
+            Some(json!({ "res_level": 2, "max_video_frames": 64 })),
+        ))
+        .await;
+    let gateway = build_router_with_state(aliyun_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-aliyun-embedding-success",
+        )
+        .json(&json!({
+            "model": "qwen3-vl-embedding",
+            "input": expected_contents,
+            "parameters": {
+                "res_level": 2,
+                "max_video_frames": 64
+            }
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["data"][0]["type"], "fusion");
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn embeddings_route_skips_openai_candidate_for_multimodal_payload() {
+    let expected_contents = json!([
+        { "text": "white running shoes" },
+        { "image": "https://example.com/shoe.png" }
+    ]);
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(aliyun_embedding_conversion_execution_runtime(
+            expected_contents.clone(),
+            Some(json!({ "enable_fusion": true })),
+        ))
+        .await;
+    let gateway = build_router_with_state(mixed_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-mixed-embedding-success",
+        )
+        .json(&json!({
+            "model": "qwen3-vl-embedding",
+            "input": expected_contents,
+            "parameters": {
+                "enable_fusion": true
+            }
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["data"][0]["type"], "fusion");
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn embeddings_route_converts_fusion_payload_to_aliyun_embedding_provider() {
+    let expected_contents = json!([
+        {
+            "text": "white running shoes",
+            "image": "https://example.com/shoe.png"
+        },
+        { "video": "https://example.com/demo.mp4" }
+    ]);
+    let (execution_runtime_url, execution_runtime_handle) =
+        start_server(aliyun_embedding_conversion_execution_runtime(
+            expected_contents.clone(),
+            Some(json!({ "enable_fusion": true })),
+        ))
+        .await;
+    let gateway = build_router_with_state(aliyun_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-aliyun-embedding-success",
+        )
+        .json(&json!({
+            "model": "qwen3-vl-embedding",
+            "input": expected_contents,
+            "parameters": {
+                "enable_fusion": true
+            }
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(response.status(), StatusCode::OK);
+    let payload: serde_json::Value = response.json().await.expect("body should parse");
+    assert_eq!(payload["data"][0]["embedding"], json!([0.1, 0.2, 0.3]));
+    assert_eq!(payload["data"][0]["type"], "fusion");
+
+    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) =
@@ -836,6 +1256,14 @@ async fn embeddings_route_rejects_invalid_local_payloads() {
             r#"{"model":"text-embedding-3-small","input":[[1],[]]}"#,
             "Embedding request input is required",
         ),
+        (
+            r#"{"model":"text-embedding-3-small","input":[{}]}"#,
+            "Embedding request input is required",
+        ),
+        (
+            r#"{"model":"text-embedding-3-small","input":[{"image":" "} ]}"#,
+            "Embedding request input is required",
+        ),
         (
             r#"{"model":"text-embedding-3-small","input":"hello","stream":true}"#,
             "Embedding requests do not support streaming",