runapi-omnihuman 0.1.1__tar.gz

runapi_omnihuman-0.1.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: runapi-omnihuman
+Version: 0.1.1
+Summary: RunAPI OmniHuman SDK for audio-to-video and image helper workflows in JavaScript, Python, Ruby, Go, Java, and PHP
+Project-URL: Homepage, https://runapi.ai/models/omnihuman
+Project-URL: Documentation, https://runapi.ai/docs#sdk-omnihuman
+Project-URL: Source, https://github.com/runapi-ai/omnihuman-sdk
+Project-URL: Issues, https://github.com/runapi-ai/omnihuman-sdk/issues
+Author-email: RunAPI <contact@runapi.ai>
+License-Expression: Apache-2.0
+Keywords: api,audio-to-video,golang,gradle,java,maven,omnihuman,omnihuman-api,python,ruby,runapi,runapi-ai,sdk,typescript,video-api,video-generation
+Requires-Python: >=3.9
+Requires-Dist: runapi-core>=0.1.4
+Description-Content-Type: text/markdown
+
+# OmniHuman Python SDK for RunAPI
+
+The OmniHuman Python SDK is the language-specific package for OmniHuman on RunAPI. Use this package for audio-driven talking-head video generation, human identification, and subject-mask detection when your application needs request bodies, task status lookup, and consistent RunAPI errors in Python.
+
+This README is the Python package guide inside the public `omnihuman-sdk` repository. For the repository overview, start at `../README.md`; for model details, use https://runapi.ai/models/omnihuman; for API reference, use https://runapi.ai/docs#omnihuman; for SDK docs, use https://runapi.ai/docs#sdk-omnihuman.
+
+## Install
+
+```bash
+pip install runapi-omnihuman
+```
+
+## Quick start
+
+```python
+from runapi.omnihuman import OmnihumanClient
+
+client = OmnihumanClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+task = client.audio_to_video.create(
+    model="omnihuman-1.5",
+    source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    source_audio_url="https://cdn.runapi.ai/public/samples/voice.mp3",
+    output_resolution="720p",
+)
+status = client.audio_to_video.get(task.id)
+```
+
+Use `create` when you want to submit a task and return quickly, `get` when you need the latest task state, and `run` when a script should create and poll until completion. In web request handlers, prefer `create` plus webhook or later `get` polling so a worker is not held open.
+
+RunAPI-generated file URLs are temporary. Download and store generated videos, masks, or other files in your own durable storage within 7 days; do not treat returned URLs as long-term assets.
+
+## Language notes
+
+Pass parameters as keyword arguments and catch the `runapi.omnihuman` error classes when building video jobs or scripts. The available resources are `audio_to_video`, `human_identification`, and `subject_detection`. Keep `RUNAPI_API_KEY` in the environment or your secret manager; never commit API keys or callback secrets.
+
+## Links
+
+- Model page: https://runapi.ai/models/omnihuman
+- SDK docs: https://runapi.ai/docs#sdk-omnihuman
+- Product docs: https://runapi.ai/docs#omnihuman
+- Pricing and rate limits: https://runapi.ai/models/omnihuman/1.5
+- Human identification: https://runapi.ai/models/omnihuman/1.5-human-identification
+- Subject detection: https://runapi.ai/models/omnihuman/1.5-subject-detection
+- Provider comparison: https://runapi.ai/providers/bytedance
+- Full catalog: https://runapi.ai/models
+- Repository: https://github.com/runapi-ai/omnihuman-sdk
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_omnihuman-0.1.1/README.md

@@ -0,0 +1,51 @@
+# OmniHuman Python SDK for RunAPI
+
+The OmniHuman Python SDK is the language-specific package for OmniHuman on RunAPI. Use this package for audio-driven talking-head video generation, human identification, and subject-mask detection when your application needs request bodies, task status lookup, and consistent RunAPI errors in Python.
+
+This README is the Python package guide inside the public `omnihuman-sdk` repository. For the repository overview, start at `../README.md`; for model details, use https://runapi.ai/models/omnihuman; for API reference, use https://runapi.ai/docs#omnihuman; for SDK docs, use https://runapi.ai/docs#sdk-omnihuman.
+
+## Install
+
+```bash
+pip install runapi-omnihuman
+```
+
+## Quick start
+
+```python
+from runapi.omnihuman import OmnihumanClient
+
+client = OmnihumanClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+task = client.audio_to_video.create(
+    model="omnihuman-1.5",
+    source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    source_audio_url="https://cdn.runapi.ai/public/samples/voice.mp3",
+    output_resolution="720p",
+)
+status = client.audio_to_video.get(task.id)
+```
+
+Use `create` when you want to submit a task and return quickly, `get` when you need the latest task state, and `run` when a script should create and poll until completion. In web request handlers, prefer `create` plus webhook or later `get` polling so a worker is not held open.
+
+RunAPI-generated file URLs are temporary. Download and store generated videos, masks, or other files in your own durable storage within 7 days; do not treat returned URLs as long-term assets.
+
+## Language notes
+
+Pass parameters as keyword arguments and catch the `runapi.omnihuman` error classes when building video jobs or scripts. The available resources are `audio_to_video`, `human_identification`, and `subject_detection`. Keep `RUNAPI_API_KEY` in the environment or your secret manager; never commit API keys or callback secrets.
+
+## Links
+
+- Model page: https://runapi.ai/models/omnihuman
+- SDK docs: https://runapi.ai/docs#sdk-omnihuman
+- Product docs: https://runapi.ai/docs#omnihuman
+- Pricing and rate limits: https://runapi.ai/models/omnihuman/1.5
+- Human identification: https://runapi.ai/models/omnihuman/1.5-human-identification
+- Subject detection: https://runapi.ai/models/omnihuman/1.5-subject-detection
+- Provider comparison: https://runapi.ai/providers/bytedance
+- Full catalog: https://runapi.ai/models
+- Repository: https://github.com/runapi-ai/omnihuman-sdk
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_omnihuman-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runapi-omnihuman"
+version = "0.1.1"
+description = "RunAPI OmniHuman SDK for audio-to-video and image helper workflows in JavaScript, Python, Ruby, Go, Java, and PHP"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "RunAPI", email = "contact@runapi.ai" }]
+keywords = ["runapi", "runapi-ai", "omnihuman", "api", "sdk", "typescript", "python", "ruby", "golang", "java", "maven", "gradle", "video-generation", "audio-to-video", "video-api", "omnihuman-api"]
+dependencies = ["runapi-core>=0.1.4"]
+
+[project.urls]
+Homepage = "https://runapi.ai/models/omnihuman"
+Documentation = "https://runapi.ai/docs#sdk-omnihuman"
+Source = "https://github.com/runapi-ai/omnihuman-sdk"
+Issues = "https://github.com/runapi-ai/omnihuman-sdk/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runapi"]
+
+[tool.uv]
+package = true
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.runapi]
+slug = "omnihuman"

runapi_omnihuman-0.1.1/src/runapi/omnihuman/__init__.py

@@ -0,0 +1,24 @@
+"""OmniHuman client for RunAPI."""
+
+from runapi.core import (
+    AuthenticationError,
+    InsufficientCreditsError,
+    NotFoundError,
+    RateLimitError,
+    TaskFailedError,
+    TaskTimeoutError,
+    ValidationError,
+)
+
+from .client import OmnihumanClient
+
+__all__ = [
+    "OmnihumanClient",
+    "AuthenticationError",
+    "RateLimitError",
+    "InsufficientCreditsError",
+    "NotFoundError",
+    "ValidationError",
+    "TaskFailedError",
+    "TaskTimeoutError",
+]

runapi_omnihuman-0.1.1/src/runapi/omnihuman/client.py

@@ -0,0 +1,33 @@
+"""OmniHuman client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import ClientOptions, HttpClient, resolve_api_key
+
+from .resources.audio_to_video import AudioToVideo
+from .resources.human_identification import HumanIdentification
+from .resources.subject_detection import SubjectDetection
+
+
+class OmnihumanClient:
+    """OmniHuman audio-to-video and helper endpoint client.
+
+    Example::
+
+        client = OmnihumanClient(api_key="sk-...")
+        result = client.audio_to_video.run(
+            model="omnihuman-1.5",
+            source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+            source_audio_url="https://cdn.runapi.ai/public/samples/voice.mp3",
+        )
+    """
+
+    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+        resolved_api_key = resolve_api_key(api_key)
+        client_options = ClientOptions(api_key=resolved_api_key, **options)
+        http = client_options.http_client or HttpClient(client_options)
+        self.audio_to_video = AudioToVideo(http)
+        self.human_identification = HumanIdentification(http)
+        self.subject_detection = SubjectDetection(http)

runapi_omnihuman-0.1.1/src/runapi/omnihuman/contract_gen.py

@@ -0,0 +1,45 @@
+CONTRACT = {
+    "audio-to-video": {
+        "models": ["omnihuman-1.5"],
+        "fields_by_model": {
+            "omnihuman-1.5": {
+                "output_resolution": {
+                    "enum": ["720p", "1080p"]
+                },
+                "prompt": {
+                    "max": 1000,
+                    "length": True
+                },
+                "seed": {
+                    "type": "integer"
+                },
+                "source_audio_url": {
+                    "required": True
+                },
+                "source_image_url": {
+                    "required": True
+                }
+            }
+        }
+    },
+    "human-identification": {
+        "models": ["omnihuman-1.5-human-identification"],
+        "fields_by_model": {
+            "omnihuman-1.5-human-identification": {
+                "source_image_url": {
+                    "required": True
+                }
+            }
+        }
+    },
+    "subject-detection": {
+        "models": ["omnihuman-1.5-subject-detection"],
+        "fields_by_model": {
+            "omnihuman-1.5-subject-detection": {
+                "source_image_url": {
+                    "required": True
+                }
+            }
+        }
+    }
+}

runapi_omnihuman-0.1.1/src/runapi/omnihuman/resources/__init__.py

@@ -0,0 +1,8 @@
+from .audio_to_video import AudioToVideo
+
+__all__ = ["AudioToVideo"]
+from .audio_to_video import AudioToVideo
+from .human_identification import HumanIdentification
+from .subject_detection import SubjectDetection
+
+__all__ = ["AudioToVideo", "HumanIdentification", "SubjectDetection"]

runapi_omnihuman-0.1.1/src/runapi/omnihuman/resources/audio_to_video.py

@@ -0,0 +1,39 @@
+"""OmniHuman audio-to-video resource."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from runapi.core import Resource, RequestOptions
+
+from ..contract_gen import CONTRACT
+from ..types import (
+    AudioToVideoResponse,
+    CompletedAudioToVideoResponse,
+)
+
+class AudioToVideo(Resource):
+    """Generate a talking-head video from a source image and audio track."""
+
+    ENDPOINT = "/api/v1/omnihuman/audio_to_video"
+
+    RESPONSE_CLASS = AudioToVideoResponse
+    COMPLETED_RESPONSE_CLASS = CompletedAudioToVideoResponse
+
+    def run(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create a task and poll until it completes."""
+        task = self.create(options=options, **params)
+        return self._poll_until_complete(lambda: self.get(task.id, options=options))
+
+    def create(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create an audio-to-video task and return immediately with an ``id``."""
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted, options=options)
+
+    def get(self, id: str, options: Optional[RequestOptions] = None) -> Any:
+        """Fetch the current status of an audio-to-video task."""
+        return self._request("get", f"{self.ENDPOINT}/{id}", options=options)
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_contract(CONTRACT["audio-to-video"], params)

runapi_omnihuman-0.1.1/src/runapi/omnihuman/resources/human_identification.py

@@ -0,0 +1,40 @@
+"""OmniHuman human-identification resource."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from runapi.core import Resource, RequestOptions
+
+from ..contract_gen import CONTRACT
+from ..types import (
+    CompletedHumanIdentificationResponse,
+    HumanIdentificationResponse,
+)
+
+
+class HumanIdentification(Resource):
+    """Identify human regions in a source image."""
+
+    ENDPOINT = "/api/v1/omnihuman/human_identification"
+
+    RESPONSE_CLASS = HumanIdentificationResponse
+    COMPLETED_RESPONSE_CLASS = CompletedHumanIdentificationResponse
+
+    def run(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create a task and poll until it completes."""
+        task = self.create(options=options, **params)
+        return self._poll_until_complete(lambda: self.get(task.id, options=options))
+
+    def create(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create a human-identification task and return immediately with an ``id``."""
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted, options=options)
+
+    def get(self, id: str, options: Optional[RequestOptions] = None) -> Any:
+        """Fetch the current status of a human-identification task."""
+        return self._request("get", f"{self.ENDPOINT}/{id}", options=options)
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_contract(CONTRACT["human-identification"], params)

runapi_omnihuman-0.1.1/src/runapi/omnihuman/resources/subject_detection.py

@@ -0,0 +1,40 @@
+"""OmniHuman subject-detection resource."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from runapi.core import Resource, RequestOptions
+
+from ..contract_gen import CONTRACT
+from ..types import (
+    CompletedSubjectDetectionResponse,
+    SubjectDetectionResponse,
+)
+
+
+class SubjectDetection(Resource):
+    """Detect subject masks in a source image."""
+
+    ENDPOINT = "/api/v1/omnihuman/subject_detection"
+
+    RESPONSE_CLASS = SubjectDetectionResponse
+    COMPLETED_RESPONSE_CLASS = CompletedSubjectDetectionResponse
+
+    def run(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create a task and poll until it completes."""
+        task = self.create(options=options, **params)
+        return self._poll_until_complete(lambda: self.get(task.id, options=options))
+
+    def create(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        """Create a subject-detection task and return immediately with an ``id``."""
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted, options=options)
+
+    def get(self, id: str, options: Optional[RequestOptions] = None) -> Any:
+        """Fetch the current status of a subject-detection task."""
+        return self._request("get", f"{self.ENDPOINT}/{id}", options=options)
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_contract(CONTRACT["subject-detection"], params)

runapi_omnihuman-0.1.1/src/runapi/omnihuman/types.py

@@ -0,0 +1,61 @@
+"""OmniHuman response models."""
+
+from __future__ import annotations
+
+from runapi.core import BaseModel, TaskResponse, optional, required
+
+
+class Video(BaseModel):
+    url = optional(str)
+
+
+class Mask(BaseModel):
+    url = optional(str)
+
+
+class AudioToVideoResponse(TaskResponse):
+    """Response for an audio-to-video task."""
+
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+    videos = optional([lambda: Video])
+    error = optional(str)
+
+
+class CompletedAudioToVideoResponse(AudioToVideoResponse):
+    """Returned by ``audio_to_video.run()`` once polling observes completion.
+
+    ``videos`` is required so callers never have to null-check it on success.
+    """
+
+    videos = required([lambda: Video])
+
+
+class HumanIdentificationResponse(TaskResponse):
+    """Response for a human-identification helper task."""
+
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+    subject_status = optional(int)
+    error = optional(str)
+
+
+class CompletedHumanIdentificationResponse(HumanIdentificationResponse):
+    """Returned by ``human_identification.run()`` once polling observes completion."""
+
+    subject_status = required(int)
+
+
+class SubjectDetectionResponse(TaskResponse):
+    """Response for a subject-detection helper task."""
+
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+    masks = optional([lambda: Mask])
+    error = optional(str)
+
+
+class CompletedSubjectDetectionResponse(SubjectDetectionResponse):
+    """Returned by ``subject_detection.run()`` once polling observes completion."""
+
+    masks = required([lambda: Mask])

runapi_omnihuman-0.1.1/tests/test_client.py

@@ -0,0 +1,214 @@
+import pytest
+
+from runapi.core import config
+from runapi.core.errors import AuthenticationError, ValidationError
+from runapi.omnihuman import OmnihumanClient
+from runapi.omnihuman.resources.audio_to_video import AudioToVideo
+from runapi.omnihuman.resources.human_identification import HumanIdentification
+from runapi.omnihuman.resources.subject_detection import SubjectDetection
+from runapi.omnihuman.types import (
+    AudioToVideoResponse,
+    CompletedAudioToVideoResponse,
+    CompletedHumanIdentificationResponse,
+    CompletedSubjectDetectionResponse,
+    HumanIdentificationResponse,
+    SubjectDetectionResponse,
+)
+
+
+class FakeHttp:
+    """Records (method, path, body) and replays preset responses by call order."""
+
+    def __init__(self, *responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body))
+        if self._responses:
+            return self._responses.pop(0)
+        return {"id": "task_1", "status": "pending"}
+
+
+@pytest.fixture(autouse=True)
+def reset_config(monkeypatch):
+    monkeypatch.delenv("RUNAPI_API_KEY", raising=False)
+    monkeypatch.setattr(config, "api_key", None)
+    yield
+
+
+VALID_AUDIO_PARAMS = dict(
+    model="omnihuman-1.5",
+    source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    source_audio_url="https://cdn.runapi.ai/public/samples/voice.mp3",
+)
+
+
+def test_accepts_api_key_parameter():
+    assert isinstance(
+        OmnihumanClient(api_key="param-key", http_client=FakeHttp()), OmnihumanClient
+    )
+
+
+def test_falls_back_to_global(monkeypatch):
+    monkeypatch.setattr(config, "api_key", "global-key")
+    assert isinstance(OmnihumanClient(http_client=FakeHttp()), OmnihumanClient)
+
+
+def test_falls_back_to_env(monkeypatch):
+    monkeypatch.setenv("RUNAPI_API_KEY", "env-key")
+    assert isinstance(OmnihumanClient(http_client=FakeHttp()), OmnihumanClient)
+
+
+def test_raises_without_api_key():
+    with pytest.raises(AuthenticationError, match="API key is required"):
+        OmnihumanClient()
+
+
+def test_exposes_resource_accessors():
+    client = OmnihumanClient(api_key="k", http_client=FakeHttp())
+    assert isinstance(client.audio_to_video, AudioToVideo)
+    assert isinstance(client.human_identification, HumanIdentification)
+    assert isinstance(client.subject_detection, SubjectDetection)
+
+
+def test_audio_to_video_create_posts_compacted_body():
+    fake = FakeHttp({"id": "t1", "status": "pending"})
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    result = client.audio_to_video.create(
+        **VALID_AUDIO_PARAMS,
+        prompt="A presenter speaks naturally to camera",
+        output_resolution="720p",
+        enable_fast_mode=True,
+        seed=None,
+    )
+    assert fake.calls == [
+        (
+            "post",
+            "/api/v1/omnihuman/audio_to_video",
+            {
+                "model": "omnihuman-1.5",
+                "source_image_url": "https://cdn.runapi.ai/public/samples/portrait.jpg",
+                "source_audio_url": "https://cdn.runapi.ai/public/samples/voice.mp3",
+                "prompt": "A presenter speaks naturally to camera",
+                "output_resolution": "720p",
+                "enable_fast_mode": True,
+            },
+        ),
+    ]
+    assert isinstance(result, AudioToVideoResponse)
+    assert result.id == "t1"
+
+
+def test_audio_to_video_get_fetches_by_id():
+    fake = FakeHttp({"id": "t1", "status": "processing"})
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    client.audio_to_video.get("t1")
+    assert fake.calls == [("get", "/api/v1/omnihuman/audio_to_video/t1", None)]
+
+
+def test_audio_to_video_run_polls_and_narrows_completed_type():
+    fake = FakeHttp(
+        {"id": "t1", "status": "pending"},
+        {"id": "t1", "status": "completed", "videos": [{"url": "https://x/y.mp4"}]},
+    )
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    result = client.audio_to_video.run(**VALID_AUDIO_PARAMS)
+
+    assert isinstance(result, CompletedAudioToVideoResponse)
+    assert result.videos[0].url == "https://x/y.mp4"
+    assert [call[0] for call in fake.calls] == ["post", "get"]
+
+
+def test_human_identification_create_and_get():
+    fake = FakeHttp(
+        {"id": "human_1", "status": "pending"},
+        {"id": "human_1", "status": "completed", "subject_status": 1},
+    )
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    task = client.human_identification.create(
+        model="omnihuman-1.5-human-identification",
+        source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    )
+    result = client.human_identification.get(task.id)
+
+    assert fake.calls[0] == (
+        "post",
+        "/api/v1/omnihuman/human_identification",
+        {
+            "model": "omnihuman-1.5-human-identification",
+            "source_image_url": "https://cdn.runapi.ai/public/samples/portrait.jpg",
+        },
+    )
+    assert fake.calls[1] == ("get", "/api/v1/omnihuman/human_identification/human_1", None)
+    assert isinstance(result, HumanIdentificationResponse)
+    assert result.subject_status == 1
+
+
+def test_human_identification_run_polls_and_narrows_completed_type():
+    fake = FakeHttp(
+        {"id": "human_1", "status": "pending"},
+        {"id": "human_1", "status": "completed", "subject_status": 1},
+    )
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    result = client.human_identification.run(
+        model="omnihuman-1.5-human-identification",
+        source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    )
+
+    assert isinstance(result, CompletedHumanIdentificationResponse)
+    assert result.subject_status == 1
+
+
+def test_subject_detection_create_and_get():
+    fake = FakeHttp(
+        {"id": "mask_1", "status": "pending"},
+        {"id": "mask_1", "status": "completed", "masks": [{"url": "https://x/mask.png"}]},
+    )
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    task = client.subject_detection.create(
+        model="omnihuman-1.5-subject-detection",
+        source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    )
+    result = client.subject_detection.get(task.id)
+
+    assert fake.calls[0] == (
+        "post",
+        "/api/v1/omnihuman/subject_detection",
+        {
+            "model": "omnihuman-1.5-subject-detection",
+            "source_image_url": "https://cdn.runapi.ai/public/samples/portrait.jpg",
+        },
+    )
+    assert fake.calls[1] == ("get", "/api/v1/omnihuman/subject_detection/mask_1", None)
+    assert isinstance(result, SubjectDetectionResponse)
+    assert result.masks[0].url == "https://x/mask.png"
+
+
+def test_subject_detection_run_polls_and_narrows_completed_type():
+    fake = FakeHttp(
+        {"id": "mask_1", "status": "pending"},
+        {"id": "mask_1", "status": "completed", "masks": [{"url": "https://x/mask.png"}]},
+    )
+    client = OmnihumanClient(api_key="k", http_client=fake)
+    result = client.subject_detection.run(
+        model="omnihuman-1.5-subject-detection",
+        source_image_url="https://cdn.runapi.ai/public/samples/portrait.jpg",
+    )
+
+    assert isinstance(result, CompletedSubjectDetectionResponse)
+    assert result.masks[0].url == "https://x/mask.png"
+
+
+def test_audio_to_video_requires_model():
+    client = OmnihumanClient(api_key="k", http_client=FakeHttp())
+    params = {k: v for k, v in VALID_AUDIO_PARAMS.items() if k != "model"}
+    with pytest.raises(ValidationError, match="model must be one of: omnihuman-1.5"):
+        client.audio_to_video.create(**params)
+
+
+def test_audio_to_video_rejects_invalid_resolution():
+    client = OmnihumanClient(api_key="k", http_client=FakeHttp())
+    params = {**VALID_AUDIO_PARAMS, "output_resolution": "480p"}
+    with pytest.raises(ValidationError, match="output_resolution must be one of: 720p, 1080p"):
+        client.audio_to_video.create(**params)