licos-dev-sdk 0.2.9__tar.gz → 0.2.11__tar.gz

{licos_dev_sdk-0.2.9 → licos_dev_sdk-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.2.9
+Version: 0.2.11
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: docxtpl>=0.16

{licos_dev_sdk-0.2.9 → licos_dev_sdk-0.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.2.9"
+version = "0.2.11"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.2.9 → licos_dev_sdk-0.2.11}/src/licos_dev_sdk/model.py

@@ -23,9 +23,11 @@ MODEL_DETAIL_PATH = "/api/v1/admin/workspaces/models/detail"
 DEFAULT_REQUEST_TIMEOUT_SECS = 120
 DEFAULT_ASYNC_TIMEOUT_SECS = 600
 DEFAULT_ASYNC_POLL_INTERVAL_SECS = 2.0
+ASYNC_MODEL_TASK_HEADER_NAME = "X-DashScope-Async"
+ASYNC_MODEL_TASK_HEADER_VALUE = "enable"
 DEFAULT_CATALOG_CACHE_TTL_SECS = 300
 
-_CATALOG_CACHE: dict[tuple[str, str, str, str, str], tuple[float, list[dict[str, Any]]]] = {}
+_CATALOG_CACHE: dict[tuple[str, str, str, str, str, str], tuple[float, list[dict[str, Any]]]] = {}
 _DETAIL_CACHE: dict[tuple[str, str, str, str], tuple[float, dict[str, Any] | None]] = {}
 
 
@@ -35,6 +37,13 @@ class ModelRuntime:
     token: str
     user_id: str | None = None
     workspace_id: str | None = None
+    owner_project_id: str | None = None
+    owner_project_type: str | None = None
+    owner_application_type: str | None = None
+    owner_org_id: str | None = None
+    runtime_env: str | None = None
+    current_user_id: str | None = None
+    current_org_id: str | None = None
 
 
 @dataclass(frozen=True)
@@ -44,6 +53,7 @@ class ModelEndpoint:
     base_url: str
     model: str
     required_headers: dict[str, str] = field(default_factory=dict)
+    request_headers: dict[str, str] = field(default_factory=dict)
     endpoint: dict[str, Any] = field(default_factory=dict)
     response_url: str | None = None
     cache_context: bool = False
@@ -173,7 +183,7 @@ def create_chat_openai(
 
     runtime = _model_runtime(base_url=base_url, user_token=user_token, user_id=user_id, workspace_id=workspace_id)
     endpoint = _resolve_chat_endpoint(runtime, model_group=model_group, requested_model=model)
-    headers = {**endpoint.required_headers, **(default_headers or {})}
+    headers = {**_request_headers(endpoint), **(default_headers or {})}
     output_tokens = max_completion_tokens if max_completion_tokens is not None else max_tokens
     chat_kwargs: dict[str, Any] = {
         "model": endpoint.model,
@@ -408,21 +418,21 @@ class ImageGenerationClient:
     ) -> ModelResult:
         endpoint = _resolve_endpoint_with_detail(self.runtime, "imageGeneration", requested_model=model)
         selected_model = endpoint.model
-        if raw_request:
-            body = dict(raw_request)
-            body.setdefault("model", selected_model)
-        else:
-            params = dict(parameters or {})
-            params["n"] = _image_count(count, params)
-            if size:
-                params["size"] = size
-            input_payload = {"prompt": prompt}
-            if negative_prompt:
-                input_payload["negative_prompt"] = negative_prompt
-            body = {"model": selected_model, "input": input_payload, "parameters": params}
-        return _submit_model_task(
-            endpoint,
-            self.runtime,
+        if raw_request:
+            body = dict(raw_request)
+            body.setdefault("model", selected_model)
+        else:
+            body = _image_generation_body(
+                prompt,
+                selected_model,
+                count=count,
+                negative_prompt=negative_prompt,
+                size=size,
+                parameters=parameters,
+            )
+        return _submit_model_task(
+            endpoint,
+            self.runtime,
             body,
             wait=wait,
             timeout=timeout,
@@ -577,17 +587,105 @@ def _model_runtime(
     owner_user_id = user_id or env("LICOS_USER_ID") or env("AGENT_USER_ID")
     resolved_workspace_id = _workspace_id(workspace_id)
     token = (user_token or "").strip() or resolve_user_token(resolved_base_url, owner_user_id)
+    current_user_id = env("LICOS_CURRENT_USER_ID") or env("AGENT_CURRENT_USER_ID")
+    current_org_id = (
+        env("LICOS_CURRENT_ORG_ID")
+        or env("AGENT_CURRENT_ORG_ID")
+        or env("LICOS_CURRENT_TENANT_ID")
+        or env("AGENT_CURRENT_TENANT_ID")
+    )
+    if not current_user_id or not current_org_id:
+        current_user_id, current_org_id = _fetch_current_user_context(resolved_base_url, token)
+    owner_project_id = env("LICOS_PROJECT_ID") or env("AGENT_PROJECT_ID")
+    owner_project_type = (
+        env("LICOS_OWNER_PROJECT_TYPE")
+        or env("AGENT_OWNER_PROJECT_TYPE")
+        or env("LICOS_PROJECT_TYPE")
+        or env("AGENT_PROJECT_TYPE")
+    )
+    owner_application_type = (
+        env("LICOS_OWNER_APPLICATION_TYPE")
+        or env("AGENT_OWNER_APPLICATION_TYPE")
+        or env("LICOS_APPLICATION_TYPE")
+        or env("AGENT_APPLICATION_TYPE")
+        or env("LICOS_OWNER_APPLIACTION_TYPE")
+        or env("AGENT_OWNER_APPLIACTION_TYPE")
+    )
+    owner_org_id = (
+        env("LICOS_OWNER_ORG_ID")
+        or env("AGENT_OWNER_ORG_ID")
+        or env("LICOS_TENANT_ID")
+        or env("AGENT_TENANT_ID")
+        or env("LICOS_ORG_ID")
+        or env("AGENT_ORG_ID")
+    )
+    runtime_env = env("LICOS_RUNTIME_ENV") or env("AGENT_RUNTIME_ENV")
+    if owner_project_id:
+        if not resolved_workspace_id:
+            raise ConfigurationError("project owner workspace ID is not configured")
+        if not owner_user_id:
+            raise ConfigurationError("project owner user ID is not configured")
+        if not runtime_env:
+            raise ConfigurationError("project runtime environment is not configured")
+        if not owner_org_id:
+            owner_org_id = _fetch_workspace_owner_org_id(resolved_base_url, token, resolved_workspace_id)
     return ModelRuntime(
         base_url=resolved_base_url,
         token=token,
         user_id=owner_user_id,
         workspace_id=resolved_workspace_id,
+        owner_project_id=owner_project_id,
+        owner_project_type=owner_project_type,
+        owner_application_type=owner_application_type,
+        owner_org_id=owner_org_id,
+        runtime_env=runtime_env,
+        current_user_id=current_user_id,
+        current_org_id=current_org_id,
     )
 
 
 def _refresh_model_runtime(runtime: ModelRuntime) -> ModelRuntime:
     token = resolve_user_token(runtime.base_url, runtime.user_id, force_refresh=True)
-    return replace(runtime, token=token)
+    current_user_id = runtime.current_user_id
+    current_org_id = runtime.current_org_id
+    if not current_user_id or not current_org_id:
+        current_user_id, current_org_id = _fetch_current_user_context(runtime.base_url, token)
+    return replace(runtime, token=token, current_user_id=current_user_id, current_org_id=current_org_id)
+
+
+def _fetch_current_user_context(base_url: str, token: str) -> tuple[str, str]:
+    payload = _request_json(
+        "GET",
+        f"{base_url}/api/v1/admin/auth/me",
+        token=token,
+        timeout=30,
+    )
+    data = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(data, dict):
+        data = payload if isinstance(payload, dict) else {}
+    user_id = _first_non_empty_field(data, ["id", "userId", "user_id", "sub"])
+    org_id = _first_non_empty_field(data, ["tenantId", "tenant_id"])
+    if not user_id:
+        raise ApiError("current user response missing id", details=payload)
+    if not org_id:
+        raise ApiError("current user response missing tenantId", details=payload)
+    return user_id, org_id
+
+
+def _fetch_workspace_owner_org_id(base_url: str, token: str, workspace_id: str) -> str:
+    payload = _request_json(
+        "GET",
+        f"{base_url}/api/v1/admin/workspaces/{parse.quote(workspace_id, safe='')}",
+        token=token,
+        timeout=30,
+    )
+    data = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(data, dict):
+        data = payload if isinstance(payload, dict) else {}
+    owner_org_id = _first_non_empty_field(data, ["tenantId", "tenant_id"])
+    if not owner_org_id:
+        raise ApiError("owner workspace response missing tenantId", details=payload)
+    return owner_org_id
 
 
 def _fetch_model_catalogs(
@@ -609,6 +707,7 @@ def _fetch_model_catalogs(
         resolved_workspace_id,
         category_code,
         input_capabilities or "",
+        _routing_cache_fingerprint(runtime),
     )
     ttl = _int_env("LICOS_MODEL_CATALOG_CACHE_TTL_SECS", DEFAULT_CATALOG_CACHE_TTL_SECS)
     cached = _CATALOG_CACHE.get(cache_key)
@@ -621,13 +720,33 @@ def _fetch_model_catalogs(
     query = {"categoryCode": category_code}
     if input_capabilities:
         query["inputCapabilities"] = input_capabilities
+    if runtime.owner_project_id:
+        query["projectId"] = runtime.owner_project_id
+    if runtime.owner_project_type:
+        query["ownerProjectType"] = runtime.owner_project_type
+    if runtime.owner_application_type:
+        query["ownerApplicationType"] = runtime.owner_application_type
+    if runtime.workspace_id:
+        query["ownerWorkspaceId"] = runtime.workspace_id
+    if runtime.owner_org_id:
+        query["tenantId"] = runtime.owner_org_id
+        query["ownerOrgId"] = runtime.owner_org_id
+    if runtime.user_id:
+        query["ownerUserId"] = runtime.user_id
+    if runtime.runtime_env:
+        query["runtimeEnv"] = runtime.runtime_env
+    if runtime.current_user_id:
+        query["currentUserId"] = runtime.current_user_id
+    if runtime.current_org_id:
+        query["currentOrgId"] = runtime.current_org_id
+        query["currentTenantId"] = runtime.current_org_id
     url = f"{runtime.base_url}{path}?{parse.urlencode(query)}"
     try:
         payload = _request_json(
             "GET",
             url,
             token=runtime.token,
-            headers={"X-Workspace-Id": resolved_workspace_id},
+            headers={**_routing_headers(runtime), "X-Workspace-Id": resolved_workspace_id},
             timeout=30,
         )
     except ApiError as exc:
@@ -655,6 +774,85 @@ def _workspace_id(workspace_id: str | None = None) -> str | None:
     return value or None
 
 
+def _routing_cache_fingerprint(runtime: ModelRuntime) -> str:
+    pairs = [
+        ("op", runtime.owner_project_id),
+        ("opt", runtime.owner_project_type),
+        ("oat", runtime.owner_application_type),
+        ("ow", runtime.workspace_id),
+        ("oo", runtime.owner_org_id),
+        ("ou", runtime.user_id),
+        ("re", runtime.runtime_env),
+        ("cu", runtime.current_user_id),
+        ("co", runtime.current_org_id),
+    ]
+    return "|".join(f"{key}={value}" for key, value in pairs if value)
+
+
+def _routing_headers(runtime: ModelRuntime) -> dict[str, str]:
+    headers: dict[str, str] = {}
+
+    def add(name: str, value: str | None) -> None:
+        if value and str(value).strip():
+            headers[name] = str(value).strip()
+
+    add("X-Licos-Current-User-Id", runtime.current_user_id)
+    add("X-Licos-Current-Org-Id", runtime.current_org_id)
+    add("X-Licos-Owner-Project-Id", runtime.owner_project_id)
+    add("X-Licos-Owner-Project-Type", runtime.owner_project_type)
+    add("X-Licos-Owner-Application-Type", runtime.owner_application_type)
+    add("X-Licos-Owner-Workspace-Id", runtime.workspace_id)
+    add("X-Licos-Owner-Org-Id", runtime.owner_org_id)
+    add("X-Licos-Owner-User-Id", runtime.user_id)
+    add("X-Licos-Runtime-Env", runtime.runtime_env)
+    add("X-Project-Id", runtime.owner_project_id)
+    add("X-Project-Type", runtime.owner_project_type)
+    add("X-Application-Type", runtime.owner_application_type)
+    add("X-Workspace-Id", runtime.workspace_id)
+    add("X-Tenant-Id", runtime.owner_org_id)
+    add("X-User-Id", runtime.user_id)
+    add("X-Runtime-Env", runtime.runtime_env)
+    return headers
+
+
+def _request_headers(endpoint: ModelEndpoint) -> dict[str, str]:
+    if endpoint.request_headers:
+        return endpoint.request_headers
+    return endpoint.required_headers
+
+
+def _task_submit_headers(endpoint: ModelEndpoint) -> dict[str, str]:
+    headers = dict(_request_headers(endpoint))
+    if _is_async_model_task(endpoint) and not any(
+        key.lower() == ASYNC_MODEL_TASK_HEADER_NAME.lower() for key in headers
+    ):
+        headers[ASYNC_MODEL_TASK_HEADER_NAME] = ASYNC_MODEL_TASK_HEADER_VALUE
+    return headers
+
+
+def _is_async_model_task(endpoint: ModelEndpoint) -> bool:
+    if endpoint.capability.strip().lower() in {"imagegeneration", "image_generation"}:
+        return False
+    return (
+        endpoint.async_task
+        or bool(endpoint.task_query_url)
+        or any(key.lower() == ASYNC_MODEL_TASK_HEADER_NAME.lower() for key in endpoint.request_headers)
+        or _is_async_model_task_capability(endpoint.capability)
+    )
+
+
+def _is_async_model_task_capability(capability: str) -> bool:
+    return capability.strip().lower() in {
+        "imagegeneration",
+        "image_generation",
+        "videogeneration",
+        "video_generation",
+        "speechrecognition",
+        "speech_recognition",
+        "speech",
+    }
+
+
 def _normalize_input_capabilities(value: str | None = None) -> str | None:
     if value is None:
         return None
@@ -685,7 +883,53 @@ def _video_input_capabilities(
             value = input_payload.get(key)
             if value is not None and str(value).strip():
                 return "image"
-    return "text"
+    return "text"
+
+
+def _image_generation_body(
+    prompt: str,
+    model: str,
+    *,
+    count: int | None = None,
+    negative_prompt: str | None = None,
+    size: str | None = None,
+    parameters: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    params = dict(parameters or {})
+    image_count = _image_count(count, params)
+    params.pop("count", None)
+    if image_count is not None:
+        params["n"] = image_count
+    else:
+        params.pop("n", None)
+    if negative_prompt:
+        params.setdefault("negative_prompt", negative_prompt)
+    if size:
+        params.setdefault("size", size)
+    return {
+        "model": model,
+        "input": {
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [{"text": prompt}],
+                }
+            ]
+        },
+        "parameters": params,
+    }
+
+
+def _image_count(count: int | None, parameters: dict[str, Any]) -> int | None:
+    values = [count, parameters.get("n"), parameters.get("count")]
+    for value in values:
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            continue
+        if parsed > 0:
+            return max(1, min(4, parsed))
+    return None
 
 
 def _fetch_model_detail(
@@ -698,20 +942,43 @@ def _fetch_model_detail(
     model_code = str(model_code or "").strip()
     if not model_code:
         return None
-    _ = workspace_id
-    cache_key = (runtime.base_url, runtime.token, model_code)
+    resolved_workspace_id = _workspace_id(workspace_id or runtime.workspace_id)
+    cache_key = (runtime.base_url, runtime.token, model_code, _routing_cache_fingerprint(runtime))
     ttl = _int_env("LICOS_MODEL_CATALOG_CACHE_TTL_SECS", DEFAULT_CATALOG_CACHE_TTL_SECS)
     cached = _DETAIL_CACHE.get(cache_key)
     if cached and not refresh and time.time() - cached[0] <= ttl:
         return cached[1]
 
     query = {"code": model_code}
+    if resolved_workspace_id:
+        query["workspaceId"] = resolved_workspace_id
+    if runtime.owner_project_id:
+        query["projectId"] = runtime.owner_project_id
+    if runtime.owner_project_type:
+        query["ownerProjectType"] = runtime.owner_project_type
+    if runtime.owner_application_type:
+        query["ownerApplicationType"] = runtime.owner_application_type
+    if runtime.workspace_id:
+        query["ownerWorkspaceId"] = runtime.workspace_id
+    if runtime.owner_org_id:
+        query["tenantId"] = runtime.owner_org_id
+        query["ownerOrgId"] = runtime.owner_org_id
+    if runtime.user_id:
+        query["ownerUserId"] = runtime.user_id
+    if runtime.runtime_env:
+        query["runtimeEnv"] = runtime.runtime_env
+    if runtime.current_user_id:
+        query["currentUserId"] = runtime.current_user_id
+    if runtime.current_org_id:
+        query["currentOrgId"] = runtime.current_org_id
+        query["currentTenantId"] = runtime.current_org_id
     url = f"{runtime.base_url}{MODEL_DETAIL_PATH}?{parse.urlencode(query)}"
     try:
         payload = _request_json(
             "GET",
             url,
             token=runtime.token,
+            headers=_routing_headers(runtime),
             timeout=30,
         )
     except ApiError as exc:
@@ -821,6 +1088,7 @@ def _resolve_endpoint(
     default_endpoint: ModelEndpoint | None = None
     for item in catalogs:
         for endpoint in _endpoint_candidates(item, capability_key, model_group):
+            endpoint = _with_request_headers(endpoint, runtime)
             default_endpoint = default_endpoint or endpoint
             if requested_model and _selected_model(requested_model, "") == endpoint.model:
                 return endpoint
@@ -829,6 +1097,11 @@ def _resolve_endpoint(
     raise ApiError(f"capability `{capability_key}` is not available in model catalog", details=catalogs)
 
 
+def _with_request_headers(endpoint: ModelEndpoint, runtime: ModelRuntime) -> ModelEndpoint:
+    headers = {**_routing_headers(runtime), **endpoint.required_headers}
+    return replace(endpoint, request_headers=headers)
+
+
 def _endpoint_candidates(
     item: dict[str, Any],
     capability_key: str,
@@ -1143,7 +1416,7 @@ def _post_model_json(
             endpoint.base_url,
             token=runtime.token,
             body=body,
-            headers=endpoint.required_headers,
+            headers=_task_submit_headers(endpoint),
             timeout=request_timeout,
         )
     except ApiError as exc:
@@ -1154,7 +1427,7 @@ def _post_model_json(
                 endpoint.base_url,
                 token=refreshed.token,
                 body=body,
-                headers=endpoint.required_headers,
+                headers=_task_submit_headers(endpoint),
                 timeout=request_timeout,
             )
         raise
@@ -1171,7 +1444,7 @@ def _submit_model_task(
 ) -> ModelResult:
     submit_response = _post_model_json(endpoint, runtime, body, timeout=timeout)
     response = submit_response
-    if endpoint.async_task and wait:
+    if _is_async_model_task(endpoint) and wait:
         response = _await_async_model_result(
             endpoint,
             runtime,
@@ -1186,7 +1459,7 @@ def _submit_model_task(
         response=response,
         urls=_collect_urls(response),
         texts=_collect_texts(response),
-        submit_response=submit_response if endpoint.async_task else None,
+        submit_response=submit_response if _is_async_model_task(endpoint) else None,
     )
 
 
@@ -1204,7 +1477,7 @@ def _stream_model_json(
             endpoint.base_url,
             token=active_runtime.token,
             body=body,
-            headers=endpoint.required_headers,
+            headers=_request_headers(endpoint),
         )
         try:
             with request.urlopen(req, timeout=timeout or _request_timeout()) as response:
@@ -1309,7 +1582,7 @@ def _await_async_model_result(
                 "GET",
                 query_url,
                 token=runtime.token,
-                headers=endpoint.required_headers,
+                headers=_request_headers(endpoint),
                 timeout=timeout or _request_timeout(),
             )
         except ApiError as exc:
@@ -1319,7 +1592,7 @@ def _await_async_model_result(
                     "GET",
                     query_url,
                     token=refreshed.token,
-                    headers=endpoint.required_headers,
+                    headers=_request_headers(endpoint),
                     timeout=timeout or _request_timeout(),
                 )
             else:
@@ -1484,19 +1757,7 @@ def _selected_model(model: str | None, default: str) -> str:
     return selected
 
 
-def _image_count(count: int | None, parameters: dict[str, Any]) -> int:
-    values = [count, parameters.get("n"), parameters.get("count")]
-    for value in values:
-        try:
-            parsed = int(value)
-        except (TypeError, ValueError):
-            continue
-        if parsed > 0:
-            return max(1, min(4, parsed))
-    return 1
-
-
-def _non_empty_list(values: Sequence[str | None]) -> list[str]:
+def _non_empty_list(values: Sequence[str | None]) -> list[str]:
     return [value.strip() for value in values if isinstance(value, str) and value.strip()]
 
 

{licos_dev_sdk-0.2.9 → licos_dev_sdk-0.2.11}/tests/test_model.py

@@ -59,14 +59,14 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "baseUrl": "http://gateway.example/v1/chat/completions",
             }
         ],
-        "image_generation": [
-            {
-                "providerCode": "test-provider",
-                "categoryCode": "image_generation",
-                "modelCode": "image-model",
-                "baseUrl": "http://gateway.example/image",
-            }
-        ],
+        "image_generation": [
+            {
+                "providerCode": "test-provider",
+                "categoryCode": "image_generation",
+                "modelCode": "image-model",
+                "baseUrl": "http://gateway.example/image",
+            }
+        ],
         "video_generation": [
             {
                 "providerCode": "test-provider",
@@ -75,6 +75,8 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "baseUrl": "http://gateway.example/video-image"
                 if input_capabilities == "image"
                 else "http://gateway.example/video-text",
+                "async": True,
+                "taskQueryUrl": "http://gateway.example/tasks/{taskId}",
             }
         ],
         "speech": [
@@ -83,6 +85,7 @@ def _available_models_payload(category_code: str = "llm", input_capabilities: st
                 "categoryCode": "speech",
                 "modelCode": "asr-model",
                 "baseUrl": "http://gateway.example/asr",
+                "taskQueryUrl": "http://gateway.example/tasks/{taskId}",
             }
         ],
     }.get(category_code, [])
@@ -105,10 +108,14 @@ def _model_detail_payload(model_code: str = "chat-text") -> dict[str, Any]:
         }
     if model_code == "image-model":
         return {
-            "code": 0,
-            "success": True,
-            "data": {"code": model_code, "baseUrl": "http://gateway.example/image"},
-        }
+            "code": 0,
+            "success": True,
+            "data": {
+                "code": model_code,
+                "baseUrl": "http://gateway.example/image",
+                "requiredHeaders": [],
+            },
+        }
     if model_code in ("video-text-model", "video-image-model"):
         suffix = "image" if model_code == "video-image-model" else "text"
         return {
@@ -116,6 +123,12 @@ def _model_detail_payload(model_code: str = "chat-text") -> dict[str, Any]:
             "success": True,
             "data": {"code": model_code, "baseUrl": f"http://gateway.example/video-{suffix}"},
         }
+    if model_code == "asr-model":
+        return {
+            "code": 0,
+            "success": True,
+            "data": {"code": model_code, "baseUrl": "http://gateway.example/asr"},
+        }
     return {
         "code": 0,
         "success": True,
@@ -152,6 +165,8 @@ class ModelSdkTests(unittest.TestCase):
                 "LICOS_PLATFORM_API_BASE_URL": "http://platform.example/api/v1",
                 "AGENT_USER_ID": "user-1",
                 "AGENT_WORKSPACE_ID": "workspace-1",
+                "LICOS_CURRENT_USER_ID": "current-user-1",
+                "LICOS_CURRENT_ORG_ID": "current-org-1",
                 "LICOS_AI_AGENT_TOKEN": "ai-agent-token",
             },
             clear=True,
@@ -170,6 +185,7 @@ class ModelSdkTests(unittest.TestCase):
                 captured["exchange_body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
             if _is_available_models_request(req):
+                captured["catalog_url"] = req.full_url
                 captured["catalog_headers"] = dict(req.header_items())
                 return _available_models_response(req)
             if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
@@ -193,6 +209,40 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(captured["chat_body"]["model"], "chat-text")
         self.assertEqual(captured["chat_body"]["max_completion_tokens"], 64000)
 
+    def test_model_requests_fetch_current_user_context_when_env_missing(self) -> None:
+        os.environ.pop("LICOS_CURRENT_USER_ID", None)
+        os.environ.pop("LICOS_CURRENT_ORG_ID", None)
+        captured: dict[str, Any] = {}
+
+        def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
+            if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
+                return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
+            if req.full_url == "http://platform.example/api/v1/admin/auth/me":
+                captured["me_headers"] = dict(req.header_items())
+                return _FakeResponse(
+                    {"code": 0, "success": True, "data": {"id": "current-user-token", "tenantId": "current-org-token"}}
+                )
+            if _is_available_models_request(req):
+                captured["catalog_url"] = req.full_url
+                captured["catalog_headers"] = dict(req.header_items())
+                return _available_models_response(req)
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload("chat-text"))
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            endpoint = model.resolve_llm_endpoint()
+
+        query = parse.parse_qs(parse.urlparse(captured["catalog_url"]).query)
+        self.assertEqual(endpoint.request_headers["X-Licos-Current-User-Id"], "current-user-token")
+        self.assertEqual(endpoint.request_headers["X-Licos-Current-Org-Id"], "current-org-token")
+        self.assertEqual(captured["me_headers"]["Authorization"], "Bearer user-token")
+        catalog_headers = {key.lower(): value for key, value in captured["catalog_headers"].items()}
+        self.assertEqual(catalog_headers["x-licos-current-user-id"], "current-user-token")
+        self.assertEqual(catalog_headers["x-licos-current-org-id"], "current-org-token")
+        self.assertEqual(query["currentUserId"], ["current-user-token"])
+        self.assertEqual(query["currentOrgId"], ["current-org-token"])
+
     def test_llm_explicit_model_overrides_catalog_default(self) -> None:
         captured: dict[str, Any] = {}
 
@@ -214,6 +264,38 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(result.text, "hello")
         self.assertEqual(captured["chat_body"]["model"], "custom-chat-model")
 
+    def test_model_catalog_request_includes_owner_project_types_when_configured(self) -> None:
+        os.environ["LICOS_PROJECT_ID"] = "project-1"
+        os.environ["LICOS_PROJECT_TYPE"] = "AGENT"
+        os.environ["LICOS_OWNER_APPLICATION_TYPE"] = "AICoding"
+        os.environ["LICOS_OWNER_ORG_ID"] = "owner-org-1"
+        os.environ["LICOS_RUNTIME_ENV"] = "dev"
+        captured: dict[str, Any] = {}
+
+        def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
+            if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
+                return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
+            if _is_available_models_request(req):
+                captured["catalog_url"] = req.full_url
+                captured["catalog_headers"] = dict(req.header_items())
+                return _available_models_response(req)
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                captured["detail_url"] = req.full_url
+                return _FakeResponse(_model_detail_payload("chat-text"))
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            endpoint = model.resolve_llm_endpoint()
+
+        catalog_query = parse.parse_qs(parse.urlparse(captured["catalog_url"]).query)
+        detail_query = parse.parse_qs(parse.urlparse(captured["detail_url"]).query)
+        self.assertEqual(endpoint.request_headers["X-Licos-Owner-Project-Type"], "AGENT")
+        self.assertEqual(endpoint.request_headers["X-Licos-Owner-Application-Type"], "AICoding")
+        self.assertEqual(catalog_query["ownerProjectType"], ["AGENT"])
+        self.assertEqual(catalog_query["ownerApplicationType"], ["AICoding"])
+        self.assertEqual(detail_query["ownerProjectType"], ["AGENT"])
+        self.assertEqual(detail_query["ownerApplicationType"], ["AICoding"])
+
     def test_llm_invoke_refreshes_user_token_once_after_unauthorized(self) -> None:
         tokens = iter(["old-token", "new-token"])
         catalog_tokens: list[str] = []
@@ -329,7 +411,7 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(kwargs["timeout"], 30)
         self.assertTrue(kwargs["streaming"])
 
-    def test_image_generation_defaults_to_one_image(self) -> None:
+    def test_image_generation_uses_sync_multimodal_body(self) -> None:
         captured: dict[str, Any] = {}
 
         def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
@@ -340,6 +422,7 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
                 return _FakeResponse(_model_detail_payload("image-model"))
             if req.full_url == "http://gateway.example/image":
+                captured["headers"] = dict(req.header_items())
                 captured["body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"output": {"url": "https://cdn.example/image.png"}})
             raise AssertionError(req.full_url)
@@ -347,9 +430,13 @@ class ModelSdkTests(unittest.TestCase):
         with mock.patch.object(model.request, "urlopen", fake_urlopen):
             result = model.ImageGenerationClient().generate("blue sky")
 
-        self.assertEqual(captured["body"]["model"], "image-model")
-        self.assertEqual(captured["body"]["parameters"]["n"], 1)
-        self.assertEqual(result.urls, ["https://cdn.example/image.png"])
+        self.assertEqual(captured["body"]["model"], "image-model")
+        self.assertEqual(captured["body"]["input"]["messages"][0]["role"], "user")
+        self.assertEqual(captured["body"]["input"]["messages"][0]["content"][0]["text"], "blue sky")
+        self.assertNotIn("n", captured["body"]["parameters"])
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertNotIn("x-dashscope-async", headers)
+        self.assertEqual(result.urls, ["https://cdn.example/image.png"])
 
     def test_video_generation_uses_text_input_capability_without_image(self) -> None:
         captured: dict[str, Any] = {}
@@ -363,6 +450,7 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
                 return _FakeResponse(_model_detail_payload("video-text-model"))
             if req.full_url == "http://gateway.example/video-text":
+                captured["headers"] = dict(req.header_items())
                 captured["body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"output": {"video_url": "https://cdn.example/text.mp4"}})
             raise AssertionError(req.full_url)
@@ -372,8 +460,38 @@ class ModelSdkTests(unittest.TestCase):
 
         self.assertEqual(captured["catalog_query"]["inputCapabilities"], ["text"])
         self.assertEqual(captured["body"]["model"], "video-text-model")
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertEqual(headers["x-dashscope-async"], "enable")
         self.assertEqual(result.urls, ["https://cdn.example/text.mp4"])
 
+    def test_speech_recognition_submits_with_async_header(self) -> None:
+        captured: dict[str, Any] = {}
+
+        def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
+            if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
+                return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
+            if _is_available_models_request(req):
+                return _available_models_response(req)
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload("asr-model"))
+            if req.full_url == "http://gateway.example/asr":
+                captured["headers"] = dict(req.header_items())
+                captured["body"] = json.loads(req.data.decode("utf-8"))
+                return _FakeResponse({"output": {"task_id": "asr-task-1", "task_status": "PENDING"}})
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            result = model.SpeechRecognitionClient().recognize(
+                audio_url="https://cdn.example/a.wav",
+                wait=False,
+            )
+
+        headers = {key.lower(): value for key, value in captured["headers"].items()}
+        self.assertEqual(headers["x-dashscope-async"], "enable")
+        self.assertEqual(captured["body"]["model"], "asr-model")
+        self.assertEqual(captured["body"]["input"]["file_urls"], ["https://cdn.example/a.wav"])
+        self.assertEqual(result.submit_response["output"]["task_id"], "asr-task-1")
+
     def test_video_generation_uses_image_input_capability_with_image(self) -> None:
         captured: dict[str, Any] = {}