genblaze-google 0.1.0__py3-none-any.whl

genblaze_google/__init__.py

@@ -0,0 +1,6 @@
+"""Google provider adapters for genblaze (Veo video, Imagen image)."""
+
+from genblaze_google.imagen import ImagenProvider
+from genblaze_google.provider import VeoProvider
+
+__all__ = ["VeoProvider", "ImagenProvider"]

genblaze_google/_errors.py

@@ -0,0 +1,19 @@
+"""Shared Google API error mapping — used by provider.py, imagen.py."""
+
+from genblaze_core.models.enums import ProviderErrorCode
+
+
+def map_google_error(exc: Exception) -> ProviderErrorCode:
+    """Map a Google API exception to a ProviderErrorCode."""
+    msg = str(exc).lower()
+    if "rate" in msg or "429" in msg or "resource_exhausted" in msg:
+        return ProviderErrorCode.RATE_LIMIT
+    if "auth" in msg or "401" in msg or "403" in msg or "permission" in msg:
+        return ProviderErrorCode.AUTH_FAILURE
+    if "invalid" in msg or "400" in msg:
+        return ProviderErrorCode.INVALID_INPUT
+    if "timeout" in msg or "deadline" in msg:
+        return ProviderErrorCode.TIMEOUT
+    if "500" in msg or "unavailable" in msg or "internal" in msg:
+        return ProviderErrorCode.SERVER_ERROR
+    return ProviderErrorCode.UNKNOWN

genblaze_google/imagen.py

@@ -0,0 +1,162 @@
+"""ImagenProvider — adapter for Google Imagen image generation.
+
+Synchronous API: client.models.generate_images() returns images directly.
+
+Docs: https://ai.google.dev/gemini-api/docs/image-generation
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from genblaze_core.exceptions import ProviderError
+from genblaze_core.models.asset import Asset
+from genblaze_core.models.enums import Modality, ProviderErrorCode
+from genblaze_core.models.step import Step
+from genblaze_core.providers.base import ProviderCapabilities, SyncProvider
+from genblaze_core.runnable.config import RunnableConfig
+
+from genblaze_google._errors import map_google_error
+
+_VALID_ASPECT_RATIOS = {"1:1", "3:4", "4:3", "9:16", "16:9"}
+
+# Per-image pricing by model (USD)
+_IMAGEN_PRICING: dict[str, float] = {
+    "imagen-3.0-generate-002": 0.04,
+    "imagen-3.0-fast-generate-001": 0.02,
+}
+
+
+class ImagenProvider(SyncProvider):
+    """Provider adapter for Google Imagen image generation.
+
+    Models: ``imagen-3.0-generate-002`` (latest), ``imagen-3.0-fast-generate-001``.
+
+    Imagen returns image bytes directly (synchronous, not operation-based).
+    Output is saved to files; use ObjectStorageSink for cloud upload.
+
+    Args:
+        api_key: Gemini API key. Falls back to GEMINI_API_KEY env var.
+        project: GCP project ID for Vertex AI auth.
+        location: GCP region for Vertex AI (default "us-central1").
+        output_dir: Directory for output image files (default system temp).
+    """
+
+    name = "google-imagen"
+
+    def get_capabilities(self) -> ProviderCapabilities:
+        """Imagen: image generation from text prompts."""
+        return ProviderCapabilities(
+            supported_modalities=[Modality.IMAGE],
+            supported_inputs=["text"],
+            models=["imagen-3.0-generate-002", "imagen-3.0-fast-generate-001"],
+            output_formats=["image/png", "image/jpeg"],
+        )
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        project: str | None = None,
+        location: str = "us-central1",
+        output_dir: str | Path | None = None,
+    ):
+        super().__init__()
+        self._api_key = api_key
+        self._project = project
+        self._location = location
+        self._output_dir = Path(output_dir) if output_dir else None
+        self._client: Any = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from google import genai
+            except ImportError as exc:
+                raise ProviderError(
+                    "google-genai package not installed. Run: pip install google-genai"
+                ) from exc
+            if self._project:
+                self._client = genai.Client(
+                    vertexai=True, project=self._project, location=self._location
+                )
+            else:
+                kwargs: dict = {}
+                if self._api_key:
+                    kwargs["api_key"] = self._api_key
+                self._client = genai.Client(**kwargs)
+        return self._client
+
+    def generate(self, step: Step, config: RunnableConfig | None = None) -> Step:
+        """Generate image(s) via the Google Imagen API."""
+        client = self._get_client()
+        try:
+            from google.genai import types
+
+            config_kwargs: dict = {}
+
+            if "number_of_images" in step.params:
+                config_kwargs["number_of_images"] = int(step.params["number_of_images"])
+            if "aspect_ratio" in step.params:
+                ar = step.params["aspect_ratio"]
+                if ar not in _VALID_ASPECT_RATIOS:
+                    raise ProviderError(
+                        f"Invalid aspect_ratio={ar!r}. Must be one of {_VALID_ASPECT_RATIOS}",
+                        error_code=ProviderErrorCode.INVALID_INPUT,
+                    )
+                config_kwargs["aspect_ratio"] = ar
+            if "person_generation" in step.params:
+                config_kwargs["person_generation"] = step.params["person_generation"]
+            if "safety_filter_level" in step.params:
+                config_kwargs["safety_filter_level"] = step.params["safety_filter_level"]
+            if "output_mime_type" in step.params:
+                config_kwargs["output_mime_type"] = step.params["output_mime_type"]
+
+            gen_config = types.GenerateImagesConfig(**config_kwargs) if config_kwargs else None
+
+            kwargs: dict = {"model": step.model, "prompt": step.prompt or ""}
+            if gen_config is not None:
+                kwargs["config"] = gen_config
+
+            response = client.models.generate_images(**kwargs)
+
+            # Safety filter can return 0 images without raising an error
+            if not response.generated_images:
+                raise ProviderError(
+                    "Imagen returned no images — prompt may have been blocked by safety filters",
+                    error_code=ProviderErrorCode.INVALID_INPUT,
+                )
+
+            mime_type = step.params.get("output_mime_type", "image/png")
+            suffix = ".jpeg" if "jpeg" in mime_type else ".png"
+
+            for i, img in enumerate(response.generated_images):
+                if self._output_dir:
+                    self._output_dir.mkdir(parents=True, exist_ok=True)
+                    out_path = self._output_dir / f"{step.step_id}_{i}{suffix}"
+                else:
+                    fd, tmp = tempfile.mkstemp(suffix=suffix)
+                    os.close(fd)
+                    out_path = Path(tmp)
+
+                img.image.save(str(out_path))
+                file_url = f"file://{quote(str(out_path.resolve()))}"
+                step.assets.append(Asset(url=file_url, media_type=mime_type))
+
+            # Track cost
+            price = _IMAGEN_PRICING.get(step.model)
+            if price is not None:
+                step.cost_usd = price * len(step.assets)
+
+            return step
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Imagen generation failed: {exc}",
+                error_code=map_google_error(exc),
+            ) from exc

genblaze_google/provider.py

@@ -0,0 +1,276 @@
+"""VeoProvider — adapter for Google Veo video generation.
+
+Uses the google-genai SDK with the async operation-based workflow:
+  client.models.generate_videos() → poll operation → download video
+
+Docs: https://ai.google.dev/gemini-api/docs/video
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from genblaze_core.exceptions import ProviderError
+from genblaze_core.models.asset import Asset, AudioMetadata, Track, VideoMetadata
+from genblaze_core.models.enums import Modality, ProviderErrorCode
+from genblaze_core.models.step import Step
+from genblaze_core.providers.base import BaseProvider, ProviderCapabilities, validate_asset_url
+from genblaze_core.runnable.config import RunnableConfig
+
+from genblaze_google._errors import map_google_error
+
+# Valid Veo parameter values
+_VALID_ASPECT_RATIOS = {"16:9", "9:16"}
+_VALID_RESOLUTIONS = {"720p", "1080p", "4k"}
+_VALID_DURATIONS = {"4", "6", "8"}
+
+# Per-second pricing by model (USD)
+_VEO_PRICING: dict[str, float] = {
+    "veo-2.0-generate-001": 0.35,
+    "veo-3.0-generate-001": 0.50,
+    "veo-3.0-fast-generate-001": 0.25,
+}
+
+
+class VeoProvider(BaseProvider):
+    """Provider adapter for Google Veo video generation.
+
+    Models: ``veo-2.0-generate-001`` (stable), ``veo-3.0-generate-001`` (GA, audio),
+    ``veo-3.0-fast-generate-001`` (GA, fast).
+
+    Supports both Gemini API (api_key) and Vertex AI (project/location) auth.
+
+    Args:
+        api_key: Gemini API key. Falls back to GEMINI_API_KEY env var.
+        project: GCP project ID for Vertex AI auth (mutually exclusive with api_key).
+        location: GCP region for Vertex AI (default "us-central1").
+        poll_interval: Seconds between operation polls (default 10).
+    """
+
+    name = "google-veo"
+
+    def get_capabilities(self) -> ProviderCapabilities:
+        """Veo: video generation from text prompts with configurable resolution and duration."""
+        return ProviderCapabilities(
+            supported_modalities=[Modality.VIDEO],
+            supported_inputs=["text"],
+            max_duration=8.0,
+            resolutions=["720p", "1080p", "4k"],
+            models=[
+                "veo-2.0-generate-001",
+                "veo-3.0-generate-001",
+                "veo-3.0-fast-generate-001",
+            ],
+            output_formats=["video/mp4"],
+        )
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        project: str | None = None,
+        location: str = "us-central1",
+        poll_interval: float = 10.0,
+    ):
+        super().__init__()
+        self.poll_interval = poll_interval
+        self._api_key = api_key
+        self._project = project
+        self._location = location
+        self._client: Any = None
+
+    def normalize_params(self, params: dict, modality: Any = None) -> dict:
+        """Map standard params to Veo-native names."""
+        p = dict(params)
+        # duration → duration_seconds (Veo's native key)
+        if "duration" in p and "duration_seconds" not in p:
+            p["duration_seconds"] = p.pop("duration")
+        return p
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from google import genai
+            except ImportError as exc:
+                raise ProviderError(
+                    "google-genai package not installed. Run: pip install google-genai"
+                ) from exc
+
+            if self._project:
+                # Vertex AI auth
+                self._client = genai.Client(
+                    vertexai=True,
+                    project=self._project,
+                    location=self._location,
+                )
+            else:
+                # Gemini API key auth
+                kwargs: dict = {}
+                if self._api_key:
+                    kwargs["api_key"] = self._api_key
+                self._client = genai.Client(**kwargs)
+        return self._client
+
+    def _build_config(self, step: Step) -> Any:
+        """Build a GenerateVideosConfig from step.params."""
+        from google.genai import types
+
+        config_kwargs: dict = {}
+
+        if "aspect_ratio" in step.params:
+            ar = step.params["aspect_ratio"]
+            if ar not in _VALID_ASPECT_RATIOS:
+                raise ProviderError(
+                    f"Invalid aspect_ratio={ar!r}. Must be one of {_VALID_ASPECT_RATIOS}",
+                    error_code=ProviderErrorCode.INVALID_INPUT,
+                )
+            config_kwargs["aspect_ratio"] = ar
+
+        if "resolution" in step.params:
+            res = step.params["resolution"]
+            if res not in _VALID_RESOLUTIONS:
+                raise ProviderError(
+                    f"Invalid resolution={res!r}. Must be one of {_VALID_RESOLUTIONS}",
+                    error_code=ProviderErrorCode.INVALID_INPUT,
+                )
+            config_kwargs["resolution"] = res
+
+        # Duration (normalize_params already mapped duration → duration_seconds)
+        raw_dur = step.params.get("duration_seconds")
+        if raw_dur is not None:
+            dur = str(raw_dur)
+            if dur not in _VALID_DURATIONS:
+                raise ProviderError(
+                    f"Invalid duration_seconds={dur!r}. Must be one of {_VALID_DURATIONS}",
+                    error_code=ProviderErrorCode.INVALID_INPUT,
+                )
+            config_kwargs["duration_seconds"] = dur
+
+        if "person_generation" in step.params:
+            config_kwargs["person_generation"] = step.params["person_generation"]
+
+        if "number_of_videos" in step.params:
+            config_kwargs["number_of_videos"] = int(step.params["number_of_videos"])
+
+        if "enhance_prompt" in step.params:
+            config_kwargs["enhance_prompt"] = bool(step.params["enhance_prompt"])
+
+        if step.seed is not None:
+            config_kwargs["seed"] = step.seed
+
+        return types.GenerateVideosConfig(**config_kwargs) if config_kwargs else None
+
+    def submit(self, step: Step, config: RunnableConfig | None = None) -> Any:
+        """Start a video generation operation."""
+        client = self._get_client()
+        try:
+            gen_config = self._build_config(step)
+            kwargs: dict = {
+                "model": step.model,
+                "prompt": step.prompt or "",
+            }
+            if gen_config is not None:
+                kwargs["config"] = gen_config
+
+            operation = client.models.generate_videos(**kwargs)
+            # Return the provider-native operation name for resume() compatibility
+            return operation.name
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Veo submit failed: {exc}",
+                error_code=map_google_error(exc),
+            ) from exc
+
+    def poll(self, prediction_id: Any, config: RunnableConfig | None = None) -> bool:
+        """Check if the video generation operation is done."""
+        client = self._get_client()
+        try:
+            operation = client.operations.get(prediction_id)
+            if operation.done:
+                self._cache_poll_result(prediction_id, operation)
+                return True
+            return False
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Veo poll failed: {exc}",
+                error_code=map_google_error(exc),
+            ) from exc
+
+    def fetch_output(self, prediction_id: Any, step: Step) -> Step:
+        """Download generated video(s) and attach asset URLs."""
+        client = self._get_client()
+        try:
+            # Use cached poll result if available, otherwise fetch fresh
+            operation = self._get_cached_poll_result(prediction_id)
+            if operation is None:
+                operation = client.operations.get(prediction_id)
+
+            # Store provider metadata
+            step.provider_payload = {
+                "google": {
+                    "operation_name": getattr(operation, "name", None),
+                    "model": step.model,
+                }
+            }
+
+            # Check for errors in the operation result
+            if hasattr(operation, "error") and operation.error:
+                raise ProviderError(
+                    str(operation.error),
+                    error_code=ProviderErrorCode.UNKNOWN,
+                )
+
+            response = operation.response
+            if response is None or not hasattr(response, "generated_videos"):
+                raise ProviderError("No video generated in response")
+
+            # Veo 3.0 models generate audio alongside video
+            is_veo3 = step.model.startswith("veo-3")
+
+            for gv in response.generated_videos:
+                video = gv.video
+                # Download to get the file URI
+                client.files.download(file=video)
+                # Use the video's URI as the asset URL
+                video_uri = getattr(video, "uri", None)
+                if video_uri:
+                    validate_asset_url(video_uri)
+                    vm_kwargs: dict[str, Any] = {"has_audio": is_veo3}
+                    if "resolution" in step.params:
+                        vm_kwargs["resolution"] = step.params["resolution"]
+                    asset = Asset(url=video_uri, media_type="video/mp4")
+                    asset.video = VideoMetadata(**vm_kwargs)
+                    # Multi-track metadata for Veo 3 (video + generated audio)
+                    if is_veo3:
+                        asset.tracks = [
+                            Track(kind="video", codec="h264"),
+                            Track(kind="audio", codec="aac", label="generated-audio"),
+                        ]
+                        asset.audio = AudioMetadata(codec="aac")
+                    step.assets.append(asset)
+                else:
+                    # Fallback: save locally and use file path
+                    raise ProviderError(
+                        "Veo response missing video URI — "
+                        "use client.files.download() to save locally"
+                    )
+
+            # Track cost — accept both native and standard duration key
+            price_per_sec = _VEO_PRICING.get(step.model)
+            if price_per_sec is not None:
+                raw_dur = step.params.get("duration_seconds") or step.params.get("duration")
+                duration = int(raw_dur) if raw_dur is not None else 4
+                step.cost_usd = price_per_sec * duration * len(step.assets)
+
+            return step
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Veo fetch_output failed: {exc}",
+                error_code=map_google_error(exc),
+            ) from exc

genblaze_google-0.1.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: genblaze-google
+Version: 0.1.0
+Summary: Google provider adapters for genblaze (Veo video, Imagen image)
+Project-URL: Documentation, https://github.com/backblaze-labs/genblaze
+Project-URL: Repository, https://github.com/backblaze-labs/genblaze
+Project-URL: Issues, https://github.com/backblaze-labs/genblaze/issues
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: genblaze-core<0.2,>=0.1.0
+Requires-Dist: google-genai>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- last_verified: 2026-04-22 -->
+# genblaze-google
+
+**Google provider adapters for [genblaze](https://github.com/backblaze-labs/genblaze) — [Veo](https://deepmind.google/technologies/veo/) text-to-video and [Imagen](https://deepmind.google/technologies/imagen-3/) text-to-image — with SHA-256 provenance manifests on every output.**
+
+`genblaze-google` wraps Google's generative media models (Veo 2, Veo 3, Imagen 3) as genblaze providers via the unified `google-genai` SDK. Works with both Gemini API keys and Google Cloud Vertex AI authentication. Compose Veo/Imagen calls into multi-step AI pipelines, persist outputs to [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) or any S3-compatible store, and emit a tamper-evident provenance manifest for every run.
+
+## Why genblaze-google
+
+- **Veo 3 with synchronized audio** — text-to-video + native audio, wrapped in a provenance manifest.
+- **Imagen 3 high-fidelity images** — photorealistic stills with full parameter tracking.
+- **Two auth modes** — Gemini API (`GEMINI_API_KEY`) for quick start, Vertex AI for enterprise / GCP orgs.
+- **Same SDK, any provider** — swap to Sora, Runway, Luma, Flux without rewriting pipeline logic.
+- **Provenance by default** — SHA-256 hash + canonical manifest on every generation.
+- **Durable storage** — plug `genblaze-s3` in for Backblaze B2 / AWS S3 / Cloudflare R2 / MinIO.
+
+## Providers + models
+
+| Provider class | Modality | Models |
+|---|---|---|
+| `VeoProvider` | video | `veo-3.0-generate-001` (with audio), `veo-3.0-fast-generate-001`, `veo-2.0-generate-001` |
+| `ImagenProvider` | image | `imagen-3.0-generate-002`, `imagen-3.0-fast-generate-001` |
+
+Each is registered via entry points (`google-veo`, `google-imagen`).
+
+## Install
+
+```bash
+pip install genblaze-google
+```
+
+## Quickstart — Veo 3 text-to-video (with audio)
+
+```bash
+export GEMINI_API_KEY="..."   # or use Vertex AI auth
+```
+
+```python
+from genblaze_core import Modality, Pipeline
+from genblaze_google import VeoProvider
+
+run, manifest = (
+    Pipeline("veo-demo")
+    .step(VeoProvider(), model="veo-3.0-generate-001",
+          prompt="A time-lapse of a coral reef coming to life, colorful fish "
+                 "swimming through vibrant coral, natural ocean lighting",
+          modality=Modality.VIDEO,
+          aspect_ratio="16:9", duration_seconds="8", resolution="720p",
+          enhance_prompt=True)
+    .run(timeout=600)
+)
+print(run.steps[0].assets[0].url, manifest.canonical_hash)
+```
+
+Vertex AI auth instead:
+
+```python
+provider = VeoProvider(project="my-gcp-project", location="us-central1")
+```
+
+## Quickstart — Imagen 3 text-to-image
+
+```python
+from genblaze_google import ImagenProvider
+
+run, manifest = (
+    Pipeline("imagen-demo")
+    .step(ImagenProvider(output_dir="output/images"),
+          model="imagen-3.0-generate-002",
+          prompt="A photorealistic aerial view of a coral reef teeming with tropical fish",
+          modality=Modality.IMAGE, aspect_ratio="16:9")
+    .run(timeout=120)
+)
+```
+
+## Persist to Backblaze B2
+
+```python
+from genblaze_core import KeyStrategy, ObjectStorageSink
+from genblaze_s3 import S3StorageBackend
+
+storage = ObjectStorageSink(
+    S3StorageBackend.for_backblaze("my-bucket"),
+    key_strategy=KeyStrategy.HIERARCHICAL,
+)
+# pass sink=storage to .run(…) to push assets + manifest to B2
+```
+
+[Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) is the recommended default sink for genblaze — cost-efficient, S3-compatible, with Object Lock for tamper-evident manifests.
+
+## Credentials
+
+| Auth mode | Env var / config |
+|---|---|
+| Gemini API (quickest) | `GEMINI_API_KEY` — https://aistudio.google.com/apikey |
+| Vertex AI | `VeoProvider(project=..., location=...)` + `gcloud auth application-default login` |
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **Examples**: [`veo_video_pipeline.py`](https://github.com/backblaze-labs/genblaze/blob/main/examples/veo_video_pipeline.py) · [`imagen_pipeline.py`](https://github.com/backblaze-labs/genblaze/blob/main/examples/imagen_pipeline.py)
+
+## Related packages
+
+- [`genblaze-core`](https://pypi.org/project/genblaze-core/) — the pipeline SDK
+- [`genblaze-s3`](https://pypi.org/project/genblaze-s3/) — durable storage on Backblaze B2 and other S3-compatible backends
+
+## License
+
+MIT

genblaze_google-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+genblaze_google/__init__.py,sha256=O8gr3PLZUZ-12sA2a34nkMTNrr_tT_K81J2otHuCk4g,216
+genblaze_google/_errors.py,sha256=mkaSFA-o_Q82jTue-nRurcoyMQ8sXCe5PbohWR8v5lE,841
+genblaze_google/imagen.py,sha256=KcswCjHrtSCLnp5J1SkrcNenhMIuRNzkO9e8NKong98,6224
+genblaze_google/provider.py,sha256=cYsHF3npwXy6aBGJXiFW5bHP2yTLzFJ2nc2_O5qori0,10747
+genblaze_google/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+genblaze_google-0.1.0.dist-info/METADATA,sha256=eXEnaPNmjxOT_PMs8u7J6RQjUip0VJvK_JrYPxR-MDw,5197
+genblaze_google-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+genblaze_google-0.1.0.dist-info/entry_points.txt,sha256=9jRx0y51zgPAxz_VJHOnVE2SOcBwDahKDVZMhVk3T-8,109
+genblaze_google-0.1.0.dist-info/RECORD,,

genblaze_google-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

genblaze_google-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[genblaze.providers]
+google-imagen = genblaze_google:ImagenProvider
+google-veo = genblaze_google:VeoProvider