runapi-gemini-omni 0.1.0__tar.gz

runapi_gemini_omni-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Build artifacts
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Bytecode
+__pycache__/
+*.py[cod]
+
+# Virtual environments
+.venv/
+venv/
+
+# uv
+uv.lock
+
+# Test / type caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# IDE / OS
+.idea/
+.vscode/
+*.swp
+.DS_Store

runapi_gemini_omni-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: runapi-gemini-omni
+Version: 0.1.0
+Summary: Gemini Omni voice, character, and text-to-video client for RunAPI
+Project-URL: Homepage, https://runapi.ai/models/gemini-omni
+Project-URL: Documentation, https://runapi.ai/docs#sdk-gemini-omni
+Author-email: RunAPI <contact@runapi.ai>
+License-Expression: Apache-2.0
+Keywords: ai,gemini,gemini-omni,runapi,sdk,text-to-video
+Requires-Python: >=3.9
+Requires-Dist: runapi-core
+Description-Content-Type: text/markdown
+
+# Gemini Omni Python SDK for RunAPI
+
+The Gemini Omni Python SDK is the language-specific package for Gemini Omni on
+RunAPI. Use it to create reusable voices and characters and to generate video
+from text, with JSON request bodies, task status lookup, and consistent RunAPI
+errors in Python.
+
+For model details, use https://runapi.ai/models/gemini-omni; for API reference,
+use https://runapi.ai/docs#gemini-omni; for SDK docs, use
+https://runapi.ai/docs#sdk-gemini-omni.
+
+## Install
+
+```bash
+pip install runapi-gemini-omni
+```
+
+## Quick start
+
+```python
+from runapi.gemini_omni import GeminiOmniClient
+
+client = GeminiOmniClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+# Reusable voice (returns immediately)
+voice = client.create_audio.run(audio_id="kore", name="Narrator")
+
+# Reusable character (returns immediately)
+character = client.create_character.run(
+    descriptions="A friendly robot guide",
+    reference_image_url="https://example.com/robot.png",
+)
+
+# Text-to-video (create + poll until complete)
+result = client.text_to_video.run(
+    prompt="A fox trotting across fresh snow at dawn",
+    duration_seconds=8,
+    aspect_ratio="16:9",
+)
+print(result.videos[0].url)
+```
+
+`create_audio` and `create_character` are synchronous: `run` submits and returns
+the result directly. `text_to_video` is asynchronous: use `create` to submit and
+return quickly, `get` to fetch the latest task state, and `run` to create and
+poll until completion.
+
+RunAPI-generated file URLs are temporary. Download and store generated 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.gemini_omni` error
+classes. The available resources are `create_audio`, `create_character`, and
+`text_to_video`. 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/gemini-omni
+- SDK docs: https://runapi.ai/docs#sdk-gemini-omni
+- Product docs: https://runapi.ai/docs#gemini-omni
+- Pricing and rate limits: https://runapi.ai/models/gemini-omni
+- Full catalog: https://runapi.ai/models
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_gemini_omni-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Gemini Omni Python SDK for RunAPI
+
+The Gemini Omni Python SDK is the language-specific package for Gemini Omni on
+RunAPI. Use it to create reusable voices and characters and to generate video
+from text, with JSON request bodies, task status lookup, and consistent RunAPI
+errors in Python.
+
+For model details, use https://runapi.ai/models/gemini-omni; for API reference,
+use https://runapi.ai/docs#gemini-omni; for SDK docs, use
+https://runapi.ai/docs#sdk-gemini-omni.
+
+## Install
+
+```bash
+pip install runapi-gemini-omni
+```
+
+## Quick start
+
+```python
+from runapi.gemini_omni import GeminiOmniClient
+
+client = GeminiOmniClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+# Reusable voice (returns immediately)
+voice = client.create_audio.run(audio_id="kore", name="Narrator")
+
+# Reusable character (returns immediately)
+character = client.create_character.run(
+    descriptions="A friendly robot guide",
+    reference_image_url="https://example.com/robot.png",
+)
+
+# Text-to-video (create + poll until complete)
+result = client.text_to_video.run(
+    prompt="A fox trotting across fresh snow at dawn",
+    duration_seconds=8,
+    aspect_ratio="16:9",
+)
+print(result.videos[0].url)
+```
+
+`create_audio` and `create_character` are synchronous: `run` submits and returns
+the result directly. `text_to_video` is asynchronous: use `create` to submit and
+return quickly, `get` to fetch the latest task state, and `run` to create and
+poll until completion.
+
+RunAPI-generated file URLs are temporary. Download and store generated 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.gemini_omni` error
+classes. The available resources are `create_audio`, `create_character`, and
+`text_to_video`. 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/gemini-omni
+- SDK docs: https://runapi.ai/docs#sdk-gemini-omni
+- Product docs: https://runapi.ai/docs#gemini-omni
+- Pricing and rate limits: https://runapi.ai/models/gemini-omni
+- Full catalog: https://runapi.ai/models
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_gemini_omni-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runapi-gemini-omni"
+version = "0.1.0"
+description = "Gemini Omni voice, character, and text-to-video client for RunAPI"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "RunAPI", email = "contact@runapi.ai" }]
+keywords = ["runapi", "gemini", "gemini-omni", "text-to-video", "ai", "sdk"]
+dependencies = ["runapi-core"]
+
+[project.urls]
+Homepage = "https://runapi.ai/models/gemini-omni"
+Documentation = "https://runapi.ai/docs#sdk-gemini-omni"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runapi"]
+
+[tool.uv]
+package = true
+
+[tool.uv.sources]
+runapi-core = { path = "../runapi-core", editable = true }
+
+[dependency-groups]
+dev = ["pytest>=8"]

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/__init__.py

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

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/client.py

@@ -0,0 +1,29 @@
+"""Gemini Omni client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import ClientOptions, HttpClient, resolve_api_key
+
+from .resources.create_audio import CreateAudio
+from .resources.create_character import CreateCharacter
+from .resources.text_to_video import TextToVideo
+
+
+class GeminiOmniClient:
+    """Gemini Omni client: reusable voices, characters, and text-to-video.
+
+    Example::
+
+        client = GeminiOmniClient(api_key="sk-...")
+        result = client.text_to_video.run(prompt="A fox in snow", duration_seconds=8)
+    """
+
+    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.create_audio = CreateAudio(http)
+        self.create_character = CreateCharacter(http)
+        self.text_to_video = TextToVideo(http)

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/resources/__init__.py

@@ -0,0 +1,5 @@
+from .create_audio import CreateAudio
+from .create_character import CreateCharacter
+from .text_to_video import TextToVideo
+
+__all__ = ["CreateAudio", "CreateCharacter", "TextToVideo"]

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/resources/create_audio.py

@@ -0,0 +1,60 @@
+"""Gemini Omni create-audio resource (synchronous)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from runapi.core import Resource, ValidationError
+
+from ..types import CreateAudioResponse
+
+
+class CreateAudio(Resource):
+    """Create a reusable voice. Synchronous: ``run()`` returns the result directly."""
+
+    ENDPOINT = "/api/v1/gemini_omni/create_audio"
+
+    RESPONSE_CLASS = CreateAudioResponse
+
+    NAME_MAX_LENGTH = 210
+    VOICE_DESCRIPTION_MAX_LENGTH = 20_000
+    EXAMPLE_DIALOGUE_MAX_LENGTH = 120
+
+    def run(self, **params: Any) -> Any:
+        """Create a reusable voice (synchronous).
+
+        Args:
+            **params: Reusable voice parameters (audio_id, name, ...).
+
+        Returns:
+            The result.
+        """
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted)
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_required(params, "audio_id")
+        self._validate_required(params, "name")
+        self._validate_length(params, "name", self.NAME_MAX_LENGTH)
+        self._validate_length(params, "voice_description", self.VOICE_DESCRIPTION_MAX_LENGTH)
+        self._validate_length(params, "example_dialogue", self.EXAMPLE_DIALOGUE_MAX_LENGTH)
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], key: str) -> None:
+        value = params.get(key)
+        if isinstance(value, list):
+            present = len(value) > 0
+        elif isinstance(value, str):
+            present = value != ""
+        else:
+            present = value is not None
+        if not present:
+            raise ValidationError(f"{key} is required")
+
+    @staticmethod
+    def _validate_length(params: Dict[str, Any], key: str, max_length: int) -> None:
+        value = params.get(key)
+        if value is None or len(str(value)) <= max_length:
+            return
+        raise ValidationError(f"{key} must be at most {max_length} characters")

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/resources/create_character.py

@@ -0,0 +1,65 @@
+"""Gemini Omni create-character resource (synchronous)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from runapi.core import Resource, ValidationError
+
+from ..types import CreateCharacterResponse
+
+
+class CreateCharacter(Resource):
+    """Create a reusable character. Synchronous: ``run()`` returns the result directly."""
+
+    ENDPOINT = "/api/v1/gemini_omni/create_character"
+
+    RESPONSE_CLASS = CreateCharacterResponse
+
+    DESCRIPTIONS_MAX_LENGTH = 20_000
+    CHARACTER_NAME_MAX_LENGTH = 210
+
+    def run(self, **params: Any) -> Any:
+        """Create a reusable character (synchronous).
+
+        Args:
+            **params: Reusable character parameters (descriptions, reference_image_url, ...).
+
+        Returns:
+            The result.
+        """
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted)
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_required(params, "descriptions")
+        self._validate_required(params, "reference_image_url")
+        if params.get("audio_ids") is not None:
+            self._validate_array(params, "audio_ids")
+        self._validate_length(params, "descriptions", self.DESCRIPTIONS_MAX_LENGTH)
+        self._validate_length(params, "character_name", self.CHARACTER_NAME_MAX_LENGTH)
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], key: str) -> None:
+        value = params.get(key)
+        if isinstance(value, list):
+            present = len(value) > 0
+        elif isinstance(value, str):
+            present = value != ""
+        else:
+            present = value is not None
+        if not present:
+            raise ValidationError(f"{key} is required")
+
+    @staticmethod
+    def _validate_array(params: Dict[str, Any], key: str) -> None:
+        if not isinstance(params.get(key), list):
+            raise ValidationError(f"{key} must be an array")
+
+    @staticmethod
+    def _validate_length(params: Dict[str, Any], key: str, max_length: int) -> None:
+        value = params.get(key)
+        if value is None or len(str(value)) <= max_length:
+            return
+        raise ValidationError(f"{key} must be at most {max_length} characters")

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/resources/text_to_video.py

@@ -0,0 +1,177 @@
+"""Gemini Omni text-to-video resource."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from runapi.core import Resource, ValidationError
+
+from ..types import (
+    ASPECT_RATIOS,
+    DURATIONS,
+    OUTPUT_RESOLUTIONS,
+    SEED_MAX,
+    SEED_MIN,
+    CompletedTextToVideoResponse,
+    TextToVideoResponse,
+)
+
+
+class TextToVideo(Resource):
+    """Generate video from a prompt, reference media, and characters."""
+
+    ENDPOINT = "/api/v1/gemini_omni/text_to_video"
+
+    RESPONSE_CLASS = TextToVideoResponse
+    COMPLETED_RESPONSE_CLASS = CompletedTextToVideoResponse
+
+    PROMPT_MAX_LENGTH = 20_000
+    REFERENCE_IMAGE_URLS_MAX = 7
+    AUDIO_IDS_MAX = 3
+    VIDEO_LIST_MAX = 1
+    CHARACTER_IDS_MAX = 3
+    REFERENCE_UNITS_MAX = 7
+    VIDEO_REFERENCE_UNITS = 2
+    MAX_TRIM_SECONDS = 10
+
+    def run(self, **params: Any) -> Any:
+        """Create a text-to-video task and poll until it completes.
+
+        Args:
+            **params: Text-to-video parameters (model, prompt, ...).
+
+        Returns:
+            The completed text-to-video response.
+        """
+        task = self.create(**params)
+        return self._poll_until_complete(lambda: self.get(task.id))
+
+    def create(self, **params: Any) -> Any:
+        """Create a text-to-video task and return immediately with an id.
+
+        Args:
+            **params: Text-to-video parameters (model, prompt, ...).
+
+        Returns:
+            The task creation result with an id.
+        """
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted)
+
+    def get(self, id: str) -> Any:
+        """Fetch the current status of a text-to-video task.
+
+        Args:
+            id: Task id.
+
+        Returns:
+            The current text-to-video status.
+        """
+        return self._request("get", f"{self.ENDPOINT}/{id}")
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        self._validate_required(params, "prompt")
+        self._validate_required(params, "duration_seconds")
+        self._validate_length(params, "prompt", self.PROMPT_MAX_LENGTH)
+        self._validate_optional(params, "duration_seconds", DURATIONS)
+        self._validate_optional(params, "aspect_ratio", ASPECT_RATIOS)
+        self._validate_optional(params, "output_resolution", OUTPUT_RESOLUTIONS)
+        if params.get("reference_image_urls") is not None:
+            self._validate_array(params, "reference_image_urls", self.REFERENCE_IMAGE_URLS_MAX)
+        if params.get("audio_ids") is not None:
+            self._validate_array(params, "audio_ids", self.AUDIO_IDS_MAX)
+        if params.get("video_list") is not None:
+            self._validate_array(params, "video_list", self.VIDEO_LIST_MAX)
+        if params.get("character_ids") is not None:
+            self._validate_array(params, "character_ids", self.CHARACTER_IDS_MAX)
+        if params.get("video_list") is not None:
+            self._validate_video_list(params.get("video_list"))
+        self._validate_reference_units(params)
+        self._validate_seed(params)
+
+    @staticmethod
+    def _validate_required(params: Dict[str, Any], key: str) -> None:
+        value = params.get(key)
+        if isinstance(value, list):
+            present = len(value) > 0
+        elif isinstance(value, str):
+            present = value != ""
+        else:
+            present = value is not None
+        if not present:
+            raise ValidationError(f"{key} is required")
+
+    @staticmethod
+    def _validate_length(params: Dict[str, Any], key: str, max_length: int) -> None:
+        value = params.get(key)
+        if value is None or len(str(value)) <= max_length:
+            return
+        raise ValidationError(f"{key} must be at most {max_length} characters")
+
+    @staticmethod
+    def _validate_array(params: Dict[str, Any], key: str, max_length: int) -> None:
+        value = params.get(key)
+        if not isinstance(value, list):
+            raise ValidationError(f"{key} must be an array")
+        if len(value) <= max_length:
+            return
+        raise ValidationError(f"{key} accepts at most {max_length} items")
+
+    def _validate_video_list(self, items: List[Dict[str, Any]]) -> None:
+        for index, item in enumerate(items):
+            url = item.get("url") if isinstance(item, dict) else None
+            if not url:
+                raise ValidationError(f"video_list[{index}].url is required")
+            start_time = self._to_float(item.get("start"))
+            end_time = self._to_float(item.get("ends"))
+            if start_time is None or end_time is None:
+                raise ValidationError(f"video_list[{index}] start and ends must be numbers")
+            if start_time < 0:
+                raise ValidationError(f"video_list[{index}].start must be 0 or greater")
+            if not end_time > start_time:
+                raise ValidationError(f"video_list[{index}].ends must be greater than start")
+            if (end_time - start_time) > self.MAX_TRIM_SECONDS:
+                raise ValidationError(
+                    f"video_list[{index}] trim range must be {self.MAX_TRIM_SECONDS} seconds or less"
+                )
+
+    def _validate_reference_units(self, params: Dict[str, Any]) -> None:
+        units = (
+            self._count(params.get("reference_image_urls"))
+            + self._count(params.get("video_list")) * self.VIDEO_REFERENCE_UNITS
+            + self._count(params.get("character_ids"))
+        )
+        if units <= self.REFERENCE_UNITS_MAX:
+            return
+        raise ValidationError(
+            f"reference_image_urls + video_list*2 + character_ids must use {self.REFERENCE_UNITS_MAX} reference units or fewer"
+        )
+
+    @staticmethod
+    def _validate_seed(params: Dict[str, Any]) -> None:
+        value = params.get("seed")
+        if value is None:
+            return
+        try:
+            seed = int(value)
+        except (TypeError, ValueError):
+            seed = None
+        if seed is not None and SEED_MIN <= seed <= SEED_MAX:
+            return
+        raise ValidationError(f"seed must be an integer between {SEED_MIN} and {SEED_MAX}")
+
+    @staticmethod
+    def _count(value: Any) -> int:
+        if value is None:
+            return 0
+        return len(value) if isinstance(value, list) else 1
+
+    @staticmethod
+    def _to_float(value: Any) -> Optional[float]:
+        if isinstance(value, bool):
+            return None
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return None

runapi_gemini_omni-0.1.0/src/runapi/gemini_omni/types.py

@@ -0,0 +1,62 @@
+"""Gemini Omni enums and response models."""
+
+from __future__ import annotations
+
+from runapi.core import BaseModel, TaskResponse, optional, required
+
+AUDIO_VOICES = [
+    "achernar", "achird", "algenib", "algieba", "alnilam", "aoede", "autonoe",
+    "callirrhoe", "charon", "despina", "enceladus", "erinome", "fenrir", "gacrux",
+    "iapetus", "kore", "laomedeia", "leda", "orus", "puck", "pulcherrima",
+    "rasalgethi", "sadachbia", "sadaltager", "schedar", "sulafat", "umbriel",
+    "vindemiatrix", "zephyr", "zubenelgenubi",
+]
+
+DURATIONS = [4, 6, 8, 10]
+ASPECT_RATIOS = ["16:9", "9:16"]
+OUTPUT_RESOLUTIONS = ["720p", "1080p", "4k"]
+SEED_MIN = 0
+SEED_MAX = 2_147_483_647
+
+
+class Audio(BaseModel):
+    id = required(str)
+    name = optional(str)
+
+
+class CreateAudioResponse(BaseModel):
+    """Result of creating a Gemini Omni reusable voice."""
+    id = required(str)
+    audio = optional(lambda: Audio)
+    error = optional(str)
+
+
+class Image(BaseModel):
+    url = optional(str)
+
+
+class Character(BaseModel):
+    id = required(str)
+    name = optional(str)
+    images = optional([lambda: Image])
+
+
+class CreateCharacterResponse(BaseModel):
+    """Result of creating a Gemini Omni reusable character."""
+    id = required(str)
+    character = optional(lambda: Character)
+    error = optional(str)
+
+
+class Video(BaseModel):
+    url = optional(str)
+
+
+class TextToVideoResponse(TaskResponse):
+    """Task status/result for Gemini Omni text-to-video."""
+    videos = optional([lambda: Video])
+
+
+class CompletedTextToVideoResponse(TextToVideoResponse):
+    """Narrowed Gemini Omni text-to-video response once polling observes completion."""
+    videos = required([lambda: Video])

runapi_gemini_omni-0.1.0/tests/test_client.py

@@ -0,0 +1,164 @@
+import pytest
+
+from runapi.core import config
+from runapi.core.errors import AuthenticationError, ValidationError
+from runapi.gemini_omni import GeminiOmniClient
+from runapi.gemini_omni.resources.create_audio import CreateAudio
+from runapi.gemini_omni.resources.create_character import CreateCharacter
+from runapi.gemini_omni.resources.text_to_video import TextToVideo
+from runapi.gemini_omni.types import (
+    CompletedTextToVideoResponse,
+    CreateAudioResponse,
+    CreateCharacterResponse,
+)
+
+
+class FakeHttp:
+    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
+
+
+# --- auth -----------------------------------------------------------------
+
+
+def test_accepts_api_key_parameter():
+    assert isinstance(GeminiOmniClient(api_key="k", http_client=FakeHttp()), GeminiOmniClient)
+
+
+def test_falls_back_to_global(monkeypatch):
+    monkeypatch.setattr(config, "api_key", "global-key")
+    assert isinstance(GeminiOmniClient(http_client=FakeHttp()), GeminiOmniClient)
+
+
+def test_falls_back_to_env(monkeypatch):
+    monkeypatch.setenv("RUNAPI_API_KEY", "env-key")
+    assert isinstance(GeminiOmniClient(http_client=FakeHttp()), GeminiOmniClient)
+
+
+def test_raises_without_api_key():
+    with pytest.raises(AuthenticationError, match="API key is required"):
+        GeminiOmniClient()
+
+
+def test_uses_injected_http_client_and_accessors():
+    fake = FakeHttp()
+    client = GeminiOmniClient(api_key="k", http_client=fake)
+    assert isinstance(client.create_audio, CreateAudio)
+    assert isinstance(client.create_character, CreateCharacter)
+    assert isinstance(client.text_to_video, TextToVideo)
+    assert client.text_to_video._http is fake
+
+
+# --- synchronous resources ------------------------------------------------
+
+
+def test_create_audio_posts_once_and_returns_typed():
+    fake = FakeHttp({"id": "a1", "audio": {"id": "kore", "name": "Narrator"}})
+    client = GeminiOmniClient(api_key="k", http_client=fake)
+    result = client.create_audio.run(audio_id="kore", name="Narrator")
+    assert fake.calls == [("post", "/api/v1/gemini_omni/create_audio", {"audio_id": "kore", "name": "Narrator"})]
+    assert isinstance(result, CreateAudioResponse)
+    assert result.audio.id == "kore"
+
+
+def test_create_audio_requires_audio_id_and_name():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="audio_id is required"):
+        client.create_audio.run(name="Narrator")
+    with pytest.raises(ValidationError, match="name is required"):
+        client.create_audio.run(audio_id="kore")
+
+
+def test_create_audio_name_length():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="name must be at most 210 characters"):
+        client.create_audio.run(audio_id="kore", name="x" * 211)
+
+
+def test_create_character_returns_typed_and_validates():
+    fake = FakeHttp({"id": "c1", "character": {"id": "c1", "name": "Robot"}})
+    client = GeminiOmniClient(api_key="k", http_client=fake)
+    result = client.create_character.run(descriptions="A robot", reference_image_url="https://x/r.png")
+    assert fake.calls[0][0:2] == ("post", "/api/v1/gemini_omni/create_character")
+    assert isinstance(result, CreateCharacterResponse)
+    assert result.character.id == "c1"
+
+
+def test_create_character_requires_fields():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="descriptions is required"):
+        client.create_character.run(reference_image_url="https://x/r.png")
+    with pytest.raises(ValidationError, match="reference_image_url is required"):
+        client.create_character.run(descriptions="A robot")
+
+
+def test_create_character_audio_ids_must_be_array():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="audio_ids must be an array"):
+        client.create_character.run(
+            descriptions="A robot", reference_image_url="https://x/r.png", audio_ids="not-a-list"
+        )
+
+
+# --- async text_to_video --------------------------------------------------
+
+
+def test_text_to_video_create_and_get_shapes():
+    fake = FakeHttp({"id": "t1", "status": "pending"}, {"id": "t1", "status": "processing"})
+    client = GeminiOmniClient(api_key="k", http_client=fake)
+    client.text_to_video.create(prompt="a fox", duration_seconds=8)
+    client.text_to_video.get("t1")
+    assert fake.calls == [
+        ("post", "/api/v1/gemini_omni/text_to_video", {"prompt": "a fox", "duration_seconds": 8}),
+        ("get", "/api/v1/gemini_omni/text_to_video/t1", None),
+    ]
+
+
+def test_text_to_video_requires_prompt_and_duration():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="prompt is required"):
+        client.text_to_video.create(duration_seconds=8)
+    with pytest.raises(ValidationError, match="duration_seconds is required"):
+        client.text_to_video.create(prompt="a fox")
+
+
+def test_text_to_video_duration_enum():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="Invalid duration_seconds"):
+        client.text_to_video.create(prompt="a fox", duration_seconds=7)
+
+
+def test_text_to_video_reference_units_cap():
+    client = GeminiOmniClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="reference units"):
+        client.text_to_video.create(
+            prompt="a fox",
+            duration_seconds=8,
+            reference_image_urls=["a", "b", "c", "d", "e"],  # 5, within array max (7)
+            character_ids=["x", "y", "z"],  # 3, within array max (3); 5 + 3 = 8 > 7 units
+        )
+
+
+def test_text_to_video_run_narrows_completed():
+    fake = FakeHttp(
+        {"id": "t1", "status": "pending"},
+        {"id": "t1", "status": "completed", "videos": [{"url": "https://x/v.mp4"}]},
+    )
+    client = GeminiOmniClient(api_key="k", http_client=fake)
+    result = client.text_to_video.run(prompt="a fox", duration_seconds=8)
+    assert isinstance(result, CompletedTextToVideoResponse)
+    assert result.videos[0].url == "https://x/v.mp4"