genblaze-google 0.1.0__tar.gz

genblaze_google-0.1.0/.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+wheels/
+/MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# IDE / editors
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.settings/
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+*.cover
+
+# Type checking
+.mypy_cache/
+.pytype/
+.pyre/
+
+# Linting
+.ruff_cache/
+
+# OS files
+.DS_Store
+Thumbs.db
+ehthumbs.db
+
+# Environment / secrets
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+credentials.json
+
+# Jupyter
+.ipynb_checkpoints/
+
+# MkDocs build output
+site/
+
+# Claude Code — local/ephemeral
+.claude/settings.local.json
+.claude/worktrees/
+CLAUDE.local.md
+
+# Hypothesis test cache
+.hypothesis/
+
+# Temp files
+*.tmp
+*.bak
+*.log

genblaze_google-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,110 @@
+<!-- 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/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-0.1.0/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-0.1.0/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-0.1.0/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/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "genblaze-google"
+version = "0.1.0"
+description = "Google provider adapters for genblaze (Veo video, Imagen image)"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Typing :: Typed",
+]
+dependencies = [
+    "genblaze-core>=0.1.0,<0.2",
+    "google-genai>=1.0",
+]
+
+[project.urls]
+Documentation = "https://github.com/backblaze-labs/genblaze"
+Repository = "https://github.com/backblaze-labs/genblaze"
+Issues = "https://github.com/backblaze-labs/genblaze/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]
+
+[project.entry-points."genblaze.providers"]
+google-veo = "genblaze_google:VeoProvider"
+google-imagen = "genblaze_google:ImagenProvider"
+
+[tool.hatch.build.targets.wheel]
+packages = ["genblaze_google"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

genblaze_google-0.1.0/tests/test_imagen_provider.py

@@ -0,0 +1,175 @@
+"""Tests for ImagenProvider (mocked — no real API calls)."""
+
+from __future__ import annotations
+
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+from genblaze_core.exceptions import ProviderError
+from genblaze_core.models.enums import StepStatus
+from genblaze_core.models.step import Step
+from genblaze_core.testing import ProviderComplianceTests
+
+
+@pytest.fixture
+def mock_imagen(tmp_path):
+    """Patch google.genai with a mock client."""
+    mock_image = MagicMock()
+    mock_image.save = MagicMock()
+
+    mock_response = MagicMock()
+    mock_response.generated_images = [MagicMock(image=mock_image)]
+
+    mock_client = MagicMock()
+    mock_client.models.generate_images.return_value = mock_response
+
+    # Mock the google.genai.types module
+    mock_types = MagicMock()
+    mock_genai = MagicMock()
+    mock_genai.types = mock_types
+    mock_google = MagicMock()
+    mock_google.genai = mock_genai
+
+    with patch.dict(
+        "sys.modules",
+        {"google": mock_google, "google.genai": mock_genai, "google.genai.types": mock_types},
+    ):
+        from genblaze_google.imagen import ImagenProvider
+
+        provider = ImagenProvider(api_key="test-key", output_dir=str(tmp_path))
+        provider._client = mock_client
+        yield provider, mock_client
+
+
+def test_generate_returns_image_asset(mock_imagen):
+    provider, _ = mock_imagen
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="a mountain landscape",
+    )
+    result = provider.generate(step)
+    assert len(result.assets) == 1
+    assert result.assets[0].media_type == "image/png"
+    assert result.assets[0].url.startswith("file://")
+
+
+def test_invoke_full_lifecycle(mock_imagen):
+    provider, _ = mock_imagen
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="a sunset",
+    )
+    result = provider.invoke(step)
+    assert result.status == StepStatus.SUCCEEDED
+    assert len(result.assets) == 1
+
+
+def test_invalid_aspect_ratio_raises(mock_imagen):
+    provider, _ = mock_imagen
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="test",
+        params={"aspect_ratio": "5:3"},
+    )
+    with pytest.raises(ProviderError, match="Invalid aspect_ratio"):
+        provider.generate(step)
+
+
+def test_multiple_images(mock_imagen):
+    provider, client = mock_imagen
+    img1, img2 = MagicMock(), MagicMock()
+    img1.image = MagicMock()
+    img2.image = MagicMock()
+    client.models.generate_images.return_value = MagicMock(generated_images=[img1, img2])
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="cats",
+        params={"number_of_images": 2},
+    )
+    result = provider.generate(step)
+    assert len(result.assets) == 2
+
+
+def test_params_passed_to_api(mock_imagen):
+    provider, client = mock_imagen
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="test",
+        params={"aspect_ratio": "16:9", "number_of_images": 2},
+    )
+    provider.generate(step)
+    client.models.generate_images.assert_called_once()
+
+
+def test_empty_images_raises_on_safety_filter(mock_imagen):
+    """Imagen safety filter returns 0 images — must raise, not return empty assets."""
+    provider, client = mock_imagen
+    client.models.generate_images.return_value = MagicMock(generated_images=[])
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="blocked content",
+    )
+    with pytest.raises(ProviderError, match="no images"):
+        provider.generate(step)
+
+
+def test_api_error_raises_provider_error(mock_imagen):
+    provider, client = mock_imagen
+    client.models.generate_images.side_effect = RuntimeError("403 permission denied")
+    step = Step(
+        provider="google-imagen",
+        model="imagen-3.0-generate-002",
+        prompt="test",
+    )
+    with pytest.raises(ProviderError, match="Imagen generation failed"):
+        provider.generate(step)
+
+
+# --- Compliance harness ---
+
+
+class TestImagenCompliance(ProviderComplianceTests):
+    """Verify ImagenProvider satisfies the genblaze provider contract."""
+
+    @pytest.fixture(autouse=True)
+    def _patch_sdk(self):
+        mock_types = MagicMock()
+        mock_genai = MagicMock()
+        mock_google_mod = MagicMock()
+        mock_google_mod.genai = mock_genai
+        with patch.dict(
+            "sys.modules",
+            {
+                "google": mock_google_mod,
+                "google.genai": mock_genai,
+                "google.genai.types": mock_types,
+            },
+        ):
+            yield
+
+    def make_provider(self):
+        from genblaze_google.imagen import ImagenProvider
+
+        mock_image = MagicMock()
+        mock_image.save = MagicMock()
+        mock_response = MagicMock()
+        mock_response.generated_images = [MagicMock(image=mock_image)]
+        mock_client = MagicMock()
+        mock_client.models.generate_images.return_value = mock_response
+        provider = ImagenProvider(api_key="test-key", output_dir=tempfile.mkdtemp())
+        provider._client = mock_client
+        return provider
+
+    def make_step(self):
+        return Step(
+            provider="google-imagen",
+            model="imagen-3.0-generate-002",
+            prompt="test prompt",
+        )

genblaze_google-0.1.0/tests/test_veo_provider.py

@@ -0,0 +1,324 @@
+"""Tests for VeoProvider (mocked — no real API calls)."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+from genblaze_core.exceptions import ProviderError
+from genblaze_core.models.enums import StepStatus
+from genblaze_core.models.step import Step
+from genblaze_core.testing import ProviderComplianceTests
+
+
+def _make_completed_operation():
+    """Create a mock completed operation with a generated video."""
+    video = SimpleNamespace(uri="https://storage.googleapis.com/video/out.mp4")
+    gv = SimpleNamespace(video=video)
+    response = SimpleNamespace(generated_videos=[gv])
+    return SimpleNamespace(done=True, name="op-123", error=None, response=response)
+
+
+def _make_pending_operation():
+    return SimpleNamespace(done=False, name="op-123", error=None, response=None)
+
+
+@pytest.fixture
+def mock_google():
+    """Patch google.genai with a mock client."""
+    mock_types = MagicMock()
+    mock_types.GenerateVideosConfig = MagicMock
+
+    mock_genai = MagicMock()
+    mock_google_mod = MagicMock()
+    mock_google_mod.genai = mock_genai
+
+    mock_client = MagicMock()
+    mock_client.models.generate_videos.return_value = _make_pending_operation()
+    mock_client.operations.get.return_value = _make_completed_operation()
+    mock_client.files.download.return_value = None
+
+    with patch.dict(
+        "sys.modules",
+        {
+            "google": mock_google_mod,
+            "google.genai": mock_genai,
+            "google.genai.types": mock_types,
+        },
+    ):
+        from genblaze_google import VeoProvider
+
+        provider = VeoProvider(api_key="test-key")
+        provider._client = mock_client
+        yield provider, mock_client
+
+
+def test_submit_returns_operation_name(mock_google):
+    provider, client = mock_google
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    pred_id = provider.submit(step)
+    # Returns the provider-native operation name, not step_id
+    assert pred_id == "op-123"
+    client.models.generate_videos.assert_called_once()
+
+
+def test_poll_returns_false_when_pending(mock_google):
+    provider, client = mock_google
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_pending_operation()
+    assert provider.poll(pred_id) is False
+
+
+def test_poll_returns_true_when_done(mock_google):
+    provider, client = mock_google
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    assert provider.poll(pred_id) is True
+
+
+def test_fetch_output_attaches_asset(mock_google):
+    provider, client = mock_google
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    pred_id = provider.submit(step)
+    # Poll to cache the completed operation
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+
+    result = provider.fetch_output(pred_id, step)
+    assert len(result.assets) == 1
+    assert result.assets[0].media_type == "video/mp4"
+    assert "storage.googleapis.com" in result.assets[0].url
+
+
+def test_fetch_output_error_raises(mock_google):
+    provider, client = mock_google
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="bad")
+    pred_id = provider.submit(step)
+    error_op = SimpleNamespace(
+        done=True, name="op-err", error="Safety filter triggered", response=None
+    )
+    client.operations.get.return_value = error_op
+    provider.poll(pred_id)
+
+    with pytest.raises(ProviderError, match="Safety filter"):
+        provider.fetch_output(pred_id, step)
+
+
+def test_invoke_full_lifecycle(mock_google):
+    """Full invoke() succeeds with mocked client."""
+    provider, client = mock_google
+    client.operations.get.return_value = _make_completed_operation()
+
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    result = provider.invoke(step)
+    assert result.status == StepStatus.SUCCEEDED
+    assert len(result.assets) == 1
+
+
+def test_invalid_aspect_ratio_raises(mock_google):
+    provider, _ = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="test",
+        params={"aspect_ratio": "4:3"},
+    )
+    with pytest.raises(ProviderError, match="Invalid aspect_ratio"):
+        provider.submit(step)
+
+
+def test_invalid_resolution_raises(mock_google):
+    provider, _ = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="test",
+        params={"resolution": "360p"},
+    )
+    with pytest.raises(ProviderError, match="Invalid resolution"):
+        provider.submit(step)
+
+
+def test_resume_works_with_operation_name(mock_google):
+    """resume() works with just the operation name (no in-memory state needed)."""
+    provider, client = mock_google
+    client.operations.get.return_value = _make_completed_operation()
+    step = Step(provider="google-veo", model="veo-2.0-generate-001", prompt="a sunset")
+    # resume with just the operation name — no prior submit() needed
+    result = provider.resume("op-123", step)
+    assert result.status == StepStatus.SUCCEEDED
+    assert len(result.assets) == 1
+
+
+def test_duration_alias(mock_google):
+    """Standard 'duration' param is aliased to 'duration_seconds' for Veo."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="test",
+        params={"duration": "6"},
+    )
+    provider.submit(step)
+    client.models.generate_videos.assert_called_once()
+
+
+def test_cost_tracked(mock_google):
+    """Cost is set based on model and duration."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="a sunset",
+        params={"duration_seconds": "6"},
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.cost_usd == pytest.approx(0.35 * 6)
+
+
+def test_cost_tracked_duration_alias(mock_google):
+    """Cost uses the standard 'duration' alias."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-3.0-generate-001",
+        prompt="a sunset",
+        params={"duration": "8"},
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.cost_usd == pytest.approx(0.50 * 8)
+
+
+def test_cost_default_duration(mock_google):
+    """Cost uses default 4s when no duration specified."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="a sunset",
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.cost_usd == pytest.approx(0.35 * 4)
+
+
+def test_cost_none_unknown_model(mock_google):
+    """Cost stays None for unknown model."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="unknown-veo-model",
+        prompt="a sunset",
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.cost_usd is None
+
+
+def test_veo3_populates_tracks(mock_google):
+    """Veo 3 models populate multi-track metadata on assets."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-3.0-generate-001",
+        prompt="a sunset with music",
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert len(result.assets) == 1
+    asset = result.assets[0]
+    assert asset.tracks is not None
+    assert len(asset.tracks) == 2
+    assert asset.tracks[0].kind == "video"
+    assert asset.tracks[0].codec == "h264"
+    assert asset.tracks[1].kind == "audio"
+    assert asset.tracks[1].codec == "aac"
+    assert asset.tracks[1].label == "generated-audio"
+
+
+def test_veo3_fast_populates_tracks(mock_google):
+    """Veo 3 fast model also populates tracks."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-3.0-fast-generate-001",
+        prompt="quick clip",
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.assets[0].tracks is not None
+    assert len(result.assets[0].tracks) == 2
+
+
+def test_veo2_no_tracks(mock_google):
+    """Veo 2 models do not populate tracks."""
+    provider, client = mock_google
+    step = Step(
+        provider="google-veo",
+        model="veo-2.0-generate-001",
+        prompt="a sunset",
+    )
+    pred_id = provider.submit(step)
+    client.operations.get.return_value = _make_completed_operation()
+    provider.poll(pred_id)
+    result = provider.fetch_output(pred_id, step)
+    assert result.assets[0].tracks is None
+
+
+# --- Compliance harness ---
+
+
+class TestVeoCompliance(ProviderComplianceTests):
+    """Verify VeoProvider satisfies the genblaze provider contract."""
+
+    @pytest.fixture(autouse=True)
+    def _patch_sdk(self):
+        mock_types = MagicMock()
+        mock_types.GenerateVideosConfig = MagicMock
+        mock_genai = MagicMock()
+        mock_google_mod = MagicMock()
+        mock_google_mod.genai = mock_genai
+        with patch.dict(
+            "sys.modules",
+            {
+                "google": mock_google_mod,
+                "google.genai": mock_genai,
+                "google.genai.types": mock_types,
+            },
+        ):
+            yield
+
+    def make_provider(self):
+        from genblaze_google import VeoProvider
+
+        mock_client = MagicMock()
+        mock_client.models.generate_videos.return_value = _make_pending_operation()
+        mock_client.operations.get.return_value = _make_completed_operation()
+        mock_client.files.download.return_value = None
+        provider = VeoProvider(api_key="test-key")
+        provider._client = mock_client
+        return provider
+
+    def make_step(self):
+        return Step(
+            provider="google-veo",
+            model="veo-2.0-generate-001",
+            prompt="test prompt",
+        )