genblaze-replicate 0.2.0__tar.gz

genblaze_replicate-0.2.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_replicate-0.2.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: genblaze-replicate
+Version: 0.2.0
+Summary: Replicate provider adapter for genblaze
+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.3,>=0.2.0
+Requires-Dist: replicate>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- last_verified: 2026-04-22 -->
+# genblaze-replicate
+
+**[Replicate](https://replicate.com) provider adapter for [genblaze](https://github.com/backblaze-labs/genblaze) — run any Replicate-hosted image, video, or audio model through a unified AI pipeline with SHA-256 provenance.**
+
+`genblaze-replicate` wraps Replicate's hosted model catalog (FLUX, SDXL, Stable Diffusion, video models, music models — anything on Replicate) as a genblaze provider. Compose Replicate calls into multi-step 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-replicate
+
+- **Any Replicate model, one API** — Pass the `owner/model` slug; genblaze handles submission, polling, asset download, and manifest capture.
+- **Provenance by default** — SHA-256 hash of every output, canonical manifest with prompt + params + timestamps.
+- **Composable** — Chain Replicate outputs into downstream steps (image → video, upscale, transcode).
+- **Production-ready** — Timeouts, retries, moderation hooks, step caching, OpenTelemetry tracing.
+- **Durable storage** — Drop the `genblaze-s3` sink in for B2/S3/R2/MinIO persistence of assets + manifests.
+
+## Models
+
+Supports any model hosted on Replicate — including:
+
+- **Image** — `black-forest-labs/flux-schnell`, `black-forest-labs/flux-dev`, `stability-ai/sdxl`, `stability-ai/stable-diffusion-3`
+- **Video** — text-to-video and image-to-video models on Replicate
+- **Audio** — music and speech models on Replicate
+
+Use the full `owner/model` slug from https://replicate.com/explore.
+
+## Install
+
+```bash
+pip install genblaze-replicate
+```
+
+Registers the `replicate` provider via entry points; [`genblaze-core`](https://pypi.org/project/genblaze-core/) discovers it automatically.
+
+## Quickstart — FLUX Schnell (text-to-image)
+
+```bash
+pip install genblaze-core genblaze-replicate
+export REPLICATE_API_TOKEN="r8_..."
+```
+
+```python
+from genblaze_core import Modality, Pipeline
+from genblaze_replicate import ReplicateProvider
+
+run, manifest = (
+    Pipeline("flux-demo")
+    .step(
+        ReplicateProvider(),
+        model="black-forest-labs/flux-schnell",
+        prompt="a photorealistic golden retriever puppy in a field of wildflowers, "
+               "golden hour, shallow depth of field",
+        modality=Modality.IMAGE,
+        num_outputs=1,
+        aspect_ratio="1:1",
+    )
+    .run()
+)
+
+print(run.steps[0].assets[0].url)
+print(manifest.canonical_hash)
+assert manifest.verify()
+```
+
+## Quickstart — persist to Backblaze B2
+
+```bash
+pip install genblaze-core genblaze-replicate genblaze-s3
+export REPLICATE_API_TOKEN="r8_..."
+export B2_KEY_ID="..."  B2_APP_KEY="..."
+```
+
+```python
+from genblaze_core import KeyStrategy, ObjectStorageSink, Pipeline
+from genblaze_replicate import ReplicateProvider
+from genblaze_s3 import S3StorageBackend
+
+storage = ObjectStorageSink(
+    S3StorageBackend.for_backblaze("my-bucket"),
+    key_strategy=KeyStrategy.CONTENT_ADDRESSABLE,
+)
+
+result = (
+    Pipeline("flux-b2")
+    .step(ReplicateProvider(), model="black-forest-labs/flux-schnell",
+          prompt="cyberpunk tokyo street at night, neon reflections on wet pavement")
+    .run(sink=storage, timeout=120)
+)
+
+print(result.run.steps[0].assets[0].url)   # durable B2 URL
+```
+
+## Credentials
+
+| Env var | Where to get it |
+|---|---|
+| `REPLICATE_API_TOKEN` | https://replicate.com/account/api-tokens |
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **Runnable example**: [`replicate_flux_pipeline.py`](https://github.com/backblaze-labs/genblaze/blob/main/examples/replicate_flux_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](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) and other S3-compatible backends
+
+## License
+
+MIT

genblaze_replicate-0.2.0/README.md

@@ -0,0 +1,110 @@
+<!-- last_verified: 2026-04-22 -->
+# genblaze-replicate
+
+**[Replicate](https://replicate.com) provider adapter for [genblaze](https://github.com/backblaze-labs/genblaze) — run any Replicate-hosted image, video, or audio model through a unified AI pipeline with SHA-256 provenance.**
+
+`genblaze-replicate` wraps Replicate's hosted model catalog (FLUX, SDXL, Stable Diffusion, video models, music models — anything on Replicate) as a genblaze provider. Compose Replicate calls into multi-step 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-replicate
+
+- **Any Replicate model, one API** — Pass the `owner/model` slug; genblaze handles submission, polling, asset download, and manifest capture.
+- **Provenance by default** — SHA-256 hash of every output, canonical manifest with prompt + params + timestamps.
+- **Composable** — Chain Replicate outputs into downstream steps (image → video, upscale, transcode).
+- **Production-ready** — Timeouts, retries, moderation hooks, step caching, OpenTelemetry tracing.
+- **Durable storage** — Drop the `genblaze-s3` sink in for B2/S3/R2/MinIO persistence of assets + manifests.
+
+## Models
+
+Supports any model hosted on Replicate — including:
+
+- **Image** — `black-forest-labs/flux-schnell`, `black-forest-labs/flux-dev`, `stability-ai/sdxl`, `stability-ai/stable-diffusion-3`
+- **Video** — text-to-video and image-to-video models on Replicate
+- **Audio** — music and speech models on Replicate
+
+Use the full `owner/model` slug from https://replicate.com/explore.
+
+## Install
+
+```bash
+pip install genblaze-replicate
+```
+
+Registers the `replicate` provider via entry points; [`genblaze-core`](https://pypi.org/project/genblaze-core/) discovers it automatically.
+
+## Quickstart — FLUX Schnell (text-to-image)
+
+```bash
+pip install genblaze-core genblaze-replicate
+export REPLICATE_API_TOKEN="r8_..."
+```
+
+```python
+from genblaze_core import Modality, Pipeline
+from genblaze_replicate import ReplicateProvider
+
+run, manifest = (
+    Pipeline("flux-demo")
+    .step(
+        ReplicateProvider(),
+        model="black-forest-labs/flux-schnell",
+        prompt="a photorealistic golden retriever puppy in a field of wildflowers, "
+               "golden hour, shallow depth of field",
+        modality=Modality.IMAGE,
+        num_outputs=1,
+        aspect_ratio="1:1",
+    )
+    .run()
+)
+
+print(run.steps[0].assets[0].url)
+print(manifest.canonical_hash)
+assert manifest.verify()
+```
+
+## Quickstart — persist to Backblaze B2
+
+```bash
+pip install genblaze-core genblaze-replicate genblaze-s3
+export REPLICATE_API_TOKEN="r8_..."
+export B2_KEY_ID="..."  B2_APP_KEY="..."
+```
+
+```python
+from genblaze_core import KeyStrategy, ObjectStorageSink, Pipeline
+from genblaze_replicate import ReplicateProvider
+from genblaze_s3 import S3StorageBackend
+
+storage = ObjectStorageSink(
+    S3StorageBackend.for_backblaze("my-bucket"),
+    key_strategy=KeyStrategy.CONTENT_ADDRESSABLE,
+)
+
+result = (
+    Pipeline("flux-b2")
+    .step(ReplicateProvider(), model="black-forest-labs/flux-schnell",
+          prompt="cyberpunk tokyo street at night, neon reflections on wet pavement")
+    .run(sink=storage, timeout=120)
+)
+
+print(result.run.steps[0].assets[0].url)   # durable B2 URL
+```
+
+## Credentials
+
+| Env var | Where to get it |
+|---|---|
+| `REPLICATE_API_TOKEN` | https://replicate.com/account/api-tokens |
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **Runnable example**: [`replicate_flux_pipeline.py`](https://github.com/backblaze-labs/genblaze/blob/main/examples/replicate_flux_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](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) and other S3-compatible backends
+
+## License
+
+MIT

genblaze_replicate-0.2.0/genblaze_replicate/__init__.py

@@ -0,0 +1,5 @@
+"""Replicate provider adapter for genblaze."""
+
+from genblaze_replicate.provider import ReplicateProvider
+
+__all__ = ["ReplicateProvider"]

genblaze_replicate-0.2.0/genblaze_replicate/_errors.py

@@ -0,0 +1,21 @@
+"""Shared Replicate error mapping — used by provider.py."""
+
+from genblaze_core.models.enums import ProviderErrorCode
+
+
+def map_replicate_error(exc_or_msg: Exception | str) -> ProviderErrorCode:
+    """Map a Replicate API exception (or error string) to a ProviderErrorCode."""
+    msg = (str(exc_or_msg)).lower()
+    if "rate" in msg or "429" in msg:
+        return ProviderErrorCode.RATE_LIMIT
+    if "auth" in msg or "401" in msg or "403" in msg or "token" in msg:
+        return ProviderErrorCode.AUTH_FAILURE
+    if "invalid" in msg or "400" in msg or "validation" in msg:
+        return ProviderErrorCode.INVALID_INPUT
+    if "timeout" in msg or "timed out" in msg:
+        return ProviderErrorCode.TIMEOUT
+    if "model" in msg and ("not found" in msg or "error" in msg or "does not exist" in msg):
+        return ProviderErrorCode.MODEL_ERROR
+    if "500" in msg or "502" in msg or "503" in msg:
+        return ProviderErrorCode.SERVER_ERROR
+    return ProviderErrorCode.UNKNOWN

genblaze_replicate-0.2.0/genblaze_replicate/provider.py

@@ -0,0 +1,202 @@
+"""ReplicateProvider — adapter for the Replicate API.
+
+Models are free-form strings (any Replicate model slug). Default pricing is
+compute-time-based (``predict_time`` × rate). Override per-model or wildcard::
+
+    from genblaze_replicate import ReplicateProvider
+    reg = ReplicateProvider.models_default().fork()
+    reg.register_pricing("owner/my-model", per_response_metric(...))
+    provider = ReplicateProvider(models=reg)
+"""
+
+from __future__ import annotations
+
+import mimetypes
+from typing import Any
+from urllib.parse import urlparse
+
+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 import (
+    BaseProvider,
+    ModelRegistry,
+    ModelSpec,
+    PricingContext,
+    ProviderCapabilities,
+    per_response_metric,
+    route_by_media_type,
+    validate_asset_url,
+)
+from genblaze_core.runnable.config import RunnableConfig
+
+from ._errors import map_replicate_error
+
+# Default per-second GPU-compute rate (Nvidia A40/T4 tier).
+_COST_PER_SEC = 0.000225
+
+
+def _compute_time_cost(ctx: PricingContext) -> float | None:
+    payload = ctx.provider_payload.get("replicate") if ctx.provider_payload else None
+    if not isinstance(payload, dict):
+        return None
+    predict_time = payload.get("predict_time")
+    if predict_time is None:
+        return None
+    try:
+        return float(predict_time) * _COST_PER_SEC
+    except (TypeError, ValueError):
+        return None
+
+
+# Replicate has no enumerable model list; fallback spec applies to every model.
+_FALLBACK_SPEC = ModelSpec(
+    model_id="*",
+    pricing=per_response_metric(_compute_time_cost),
+    input_mapping=route_by_media_type({"image": "image", "video": "video", "audio": "audio"}),
+)
+
+
+class ReplicateProvider(BaseProvider):
+    """Provider adapter for Replicate (replicate.com)."""
+
+    name = "replicate"
+
+    @classmethod
+    def create_registry(cls) -> ModelRegistry:
+        # No enumerable defaults — every model uses the fallback spec.
+        return ModelRegistry(defaults={}, fallback=_FALLBACK_SPEC)
+
+    def get_capabilities(self) -> ProviderCapabilities:
+        """Replicate: multi-modal generation depending on selected model."""
+        return ProviderCapabilities(
+            supported_modalities=[Modality.IMAGE, Modality.VIDEO, Modality.AUDIO],
+            supported_inputs=["text", "image", "video", "audio"],
+            accepts_chain_input=True,
+        )
+
+    def __init__(
+        self,
+        api_token: str | None = None,
+        poll_interval: float = 1.0,
+        http_timeout: float = 30.0,
+        *,
+        models: ModelRegistry | None = None,
+    ):
+        super().__init__(models=models)
+        self.poll_interval = poll_interval
+        self._client: Any = None
+        self._api_token = api_token
+        self._http_timeout = http_timeout
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import httpx
+                import replicate
+
+                timeout = httpx.Timeout(self._http_timeout, connect=10.0)
+                if self._api_token:
+                    self._client = replicate.Client(
+                        api_token=self._api_token,  # noqa: S106
+                        timeout=timeout,
+                    )
+                else:
+                    self._client = replicate.Client(timeout=timeout)
+            except ImportError as exc:
+                raise ProviderError(
+                    "replicate package not installed. Run: pip install replicate"
+                ) from exc
+        return self._client
+
+    def submit(self, step: Step, config: RunnableConfig | None = None) -> Any:
+        client = self._get_client()
+        try:
+            input_params = self.prepare_payload(step)
+            prediction = client.predictions.create(
+                model=step.model,
+                input=input_params,
+            )
+            return prediction.id
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate submit failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc
+
+    def poll(self, prediction_id: Any, config: RunnableConfig | None = None) -> bool:
+        client = self._get_client()
+        try:
+            prediction = client.predictions.get(prediction_id)
+            if prediction.status in ("succeeded", "failed", "canceled"):
+                self._cache_poll_result(prediction_id, prediction)
+                return True
+            return False
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate poll failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc
+
+    def fetch_output(self, prediction_id: Any, step: Step) -> Step:
+        client = self._get_client()
+        try:
+            prediction = self._get_cached_poll_result(prediction_id)
+            if prediction is None:
+                prediction = client.predictions.get(prediction_id)
+
+            # Capture predict_time so registry pricing can read it.
+            metrics = getattr(prediction, "metrics", None)
+            predict_time = getattr(metrics, "predict_time", None) if metrics else None
+
+            step.provider_payload = {
+                "replicate": {
+                    "prediction_id": prediction.id,
+                    "model": prediction.model if hasattr(prediction, "model") else None,
+                    "version": prediction.version if hasattr(prediction, "version") else None,
+                    "status": prediction.status,
+                    "created_at": str(prediction.created_at)
+                    if hasattr(prediction, "created_at")
+                    else None,
+                    "predict_time": predict_time,
+                }
+            }
+
+            if prediction.status == "failed":
+                error_msg = prediction.error or "Unknown error"
+                raise ProviderError(
+                    error_msg,
+                    error_code=map_replicate_error(error_msg),
+                )
+
+            if prediction.status == "canceled":
+                raise ProviderError(
+                    "Prediction was canceled",
+                    error_code=ProviderErrorCode.UNKNOWN,
+                )
+
+            output = prediction.output
+            if isinstance(output, str):
+                output = [output]
+            elif output is None:
+                output = []
+
+            for url in output:
+                url_str = str(url)
+                validate_asset_url(url_str)
+                path = urlparse(url_str).path
+                mime, _ = mimetypes.guess_type(path)
+                if mime is None:
+                    mime = f"{step.modality.value}/octet-stream"
+                step.assets.append(Asset(url=url_str, media_type=mime))
+
+            self._apply_registry_pricing(step)
+            return step
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate fetch_output failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc

genblaze_replicate-0.2.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "genblaze-replicate"
+version = "0.2.0"
+description = "Replicate provider adapter for genblaze"
+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.2.0,<0.3",
+    "replicate>=0.25",
+]
+
+[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"]
+replicate = "genblaze_replicate:ReplicateProvider"
+
+[tool.hatch.build.targets.wheel]
+packages = ["genblaze_replicate"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

genblaze_replicate-0.2.0/tests/test_replicate_provider.py

@@ -0,0 +1,333 @@
+"""Tests for ReplicateProvider with mocked Replicate API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from genblaze_core.models.enums import ProviderErrorCode
+from genblaze_core.models.step import Step
+from genblaze_core.testing import ProviderComplianceTests
+from genblaze_replicate._errors import map_replicate_error
+from genblaze_replicate.provider import ReplicateProvider
+
+
+@dataclass
+class FakePrediction:
+    """Minimal mock of a Replicate prediction object."""
+
+    id: str = "pred-abc123"
+    status: str = "succeeded"
+    output: Any = field(default_factory=lambda: ["https://example.com/out.png"])
+    error: str | None = None
+    model: str = "test/model"
+    version: str | None = "v1"
+    created_at: str = "2026-01-01T00:00:00Z"
+
+
+def _make_step(**kwargs) -> Step:
+    defaults = {"provider": "replicate", "model": "test/model", "prompt": "a cat"}
+    defaults.update(kwargs)
+    return Step(**defaults)
+
+
+# --- map_replicate_error tests ---
+
+
+def test_map_error_timeout():
+    assert map_replicate_error("Request timed out") == ProviderErrorCode.TIMEOUT
+
+
+def test_map_error_rate_limit():
+    assert map_replicate_error("rate limit exceeded 429") == ProviderErrorCode.RATE_LIMIT
+
+
+def test_map_error_auth():
+    assert map_replicate_error("401 unauthorized token") == ProviderErrorCode.AUTH_FAILURE
+
+
+def test_map_error_invalid_input():
+    assert map_replicate_error("invalid input: bad format") == ProviderErrorCode.INVALID_INPUT
+
+
+def test_map_error_model_not_found():
+    assert map_replicate_error("model not found") == ProviderErrorCode.MODEL_ERROR
+
+
+def test_map_error_server_error():
+    assert map_replicate_error("500 internal server error") == ProviderErrorCode.SERVER_ERROR
+
+
+def test_map_error_unknown():
+    assert map_replicate_error("something went wrong") == ProviderErrorCode.UNKNOWN
+
+
+def test_map_error_accepts_exception():
+    """map_replicate_error should accept Exception objects too."""
+    assert map_replicate_error(RuntimeError("timed out")) == ProviderErrorCode.TIMEOUT
+
+
+# --- submit tests ---
+
+
+def test_submit_sends_prompt_and_params():
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.create.return_value = FakePrediction()
+    provider._client = mock_client
+
+    step = _make_step(params={"width": 1024})
+    result = provider.submit(step)
+
+    mock_client.predictions.create.assert_called_once_with(
+        model="test/model",
+        input={"width": 1024, "prompt": "a cat"},
+    )
+    assert result == "pred-abc123"
+
+
+def test_submit_includes_negative_prompt():
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.create.return_value = FakePrediction()
+    provider._client = mock_client
+
+    step = _make_step(negative_prompt="blurry")
+    provider.submit(step)
+
+    call_input = mock_client.predictions.create.call_args.kwargs["input"]
+    assert call_input["negative_prompt"] == "blurry"
+
+
+# --- poll tests ---
+
+
+def test_poll_returns_true_on_success():
+    provider = ReplicateProvider(api_token="test-token", poll_interval=0.0)
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(status="succeeded")
+    provider._client = mock_client
+
+    assert provider.poll("pred-abc123") is True
+
+
+def test_poll_returns_true_on_failed():
+    provider = ReplicateProvider(api_token="test-token", poll_interval=0.0)
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(status="failed")
+    provider._client = mock_client
+
+    assert provider.poll("pred-abc123") is True
+
+
+def test_poll_returns_true_on_canceled():
+    provider = ReplicateProvider(api_token="test-token", poll_interval=0.0)
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(status="canceled")
+    provider._client = mock_client
+
+    assert provider.poll("pred-abc123") is True
+
+
+def test_poll_returns_false_on_processing():
+    provider = ReplicateProvider(api_token="test-token", poll_interval=0.0)
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(status="processing")
+    provider._client = mock_client
+
+    assert provider.poll("pred-abc123") is False
+
+
+# --- fetch_output tests ---
+
+
+def test_fetch_output_success_with_list():
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(
+        output=["https://example.com/a.png", "https://example.com/b.png"]
+    )
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+
+    assert len(result.assets) == 2
+    assert result.assets[0].url == "https://example.com/a.png"
+
+
+def test_fetch_output_success_with_string():
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(
+        output="https://example.com/single.png"
+    )
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+
+    assert len(result.assets) == 1
+    assert result.assets[0].url == "https://example.com/single.png"
+
+
+def test_fetch_output_success_with_none():
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(output=None)
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+
+    assert len(result.assets) == 0
+
+
+def test_fetch_output_failed():
+    from genblaze_core.exceptions import ProviderError
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(
+        status="failed", error="Model crashed"
+    )
+    provider._client = mock_client
+
+    step = _make_step()
+    with pytest.raises(ProviderError, match="Model crashed"):
+        provider.fetch_output("pred-abc123", step)
+
+
+def test_fetch_output_canceled():
+    from genblaze_core.exceptions import ProviderError
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(status="canceled")
+    provider._client = mock_client
+
+    step = _make_step()
+    with pytest.raises(ProviderError, match="canceled"):
+        provider.fetch_output("pred-abc123", step)
+
+
+# --- Token safety ---
+
+
+def test_fetch_output_rejects_non_https_url():
+    """Asset URLs must be HTTPS to prevent SSRF via malicious provider output."""
+    from genblaze_core.exceptions import ProviderError
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(output=["file:///etc/passwd"])
+    provider._client = mock_client
+
+    step = _make_step()
+    with pytest.raises(ProviderError, match="Unsafe asset URL"):
+        provider.fetch_output("pred-abc123", step)
+
+
+def test_fetch_output_rejects_http_url():
+    """Plain HTTP URLs rejected — could target internal metadata endpoints."""
+    from genblaze_core.exceptions import ProviderError
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(
+        output=["http://169.254.169.254/latest/meta-data/"]
+    )
+    provider._client = mock_client
+
+    step = _make_step()
+    with pytest.raises(ProviderError, match="Unsafe asset URL"):
+        provider.fetch_output("pred-abc123", step)
+
+
+def test_fetch_output_rejects_schemeless_url():
+    """Scheme-less URLs rejected — urlparse sets empty scheme for these."""
+    from genblaze_core.exceptions import ProviderError
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction(
+        output=["//169.254.169.254/latest/meta-data/"]
+    )
+    provider._client = mock_client
+
+    step = _make_step()
+    with pytest.raises(ProviderError, match="Unsafe asset URL"):
+        provider.fetch_output("pred-abc123", step)
+
+
+def test_cost_tracked_from_metrics():
+    """Cost is computed from prediction.metrics.predict_time."""
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    pred = FakePrediction()
+    pred.metrics = MagicMock()
+    pred.metrics.predict_time = 10.0
+    mock_client.predictions.get.return_value = pred
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+    assert result.cost_usd is not None
+    assert result.cost_usd == pytest.approx(10.0 * 0.000225)
+
+
+def test_cost_none_without_metrics():
+    """Cost stays None when prediction has no metrics."""
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    pred = FakePrediction()
+    # No metrics attribute
+    mock_client.predictions.get.return_value = pred
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+    assert result.cost_usd is None
+
+
+def test_token_not_in_provider_payload():
+    """API token must never leak into the provider_payload stored in manifests."""
+    provider = ReplicateProvider(api_token="r8_secret_token_123")
+    mock_client = MagicMock()
+    mock_client.predictions.get.return_value = FakePrediction()
+    provider._client = mock_client
+
+    step = _make_step()
+    result = provider.fetch_output("pred-abc123", step)
+
+    # Serialize the entire payload and check token is absent
+    import json
+
+    payload_str = json.dumps(result.provider_payload)
+    assert "r8_secret_token_123" not in payload_str
+
+
+# --- Compliance harness ---
+
+
+class TestReplicateCompliance(ProviderComplianceTests):
+    """Verify ReplicateProvider satisfies the genblaze provider contract."""
+
+    # ReplicateProvider populates cost_usd from prediction.metrics.predict_time,
+    # but the FakePrediction compliance fixture doesn't expose that metric.
+    # A dedicated test (test_cost_tracked_from_predict_time) covers the real
+    # code path; compliance waives the check here.
+    expects_cost = False
+
+    def make_provider(self):
+        provider = ReplicateProvider(api_token="test-token")
+        mock_client = MagicMock()
+        mock_client.predictions.create.return_value = FakePrediction()
+        mock_client.predictions.get.return_value = FakePrediction()
+        provider._client = mock_client
+        return provider
+
+    def make_step(self):
+        return Step(provider="replicate", model="test/model", prompt="a cat")