genblaze-replicate 0.2.2__tar.gz → 0.3.0__tar.gz

{genblaze_replicate-0.2.2 → genblaze_replicate-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genblaze-replicate
-Version: 0.2.2
+Version: 0.3.0
 Summary: Replicate provider adapter for genblaze
 Project-URL: Homepage, https://github.com/backblaze-labs/genblaze
 Project-URL: Documentation, https://github.com/backblaze-labs/genblaze
@@ -8,11 +8,17 @@ Project-URL: Repository, https://github.com/backblaze-labs/genblaze
 Project-URL: Issues, https://github.com/backblaze-labs/genblaze/issues
 Author-email: Jeronimo De Leon <jdeleon@backblaze.com>
 License-Expression: MIT
+Keywords: ai,c2pa-ready,genai,genblaze,image,manifest,media,pipeline,provenance,replicate,video
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia
+Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: genblaze-core<0.3,>=0.2.0
+Requires-Dist: genblaze-core<0.4,>=0.3.0
 Requires-Dist: replicate>=0.25
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == 'dev'

{genblaze_replicate-0.2.2 → genblaze_replicate-0.3.0}/genblaze_replicate/__init__.py

@@ -2,4 +2,6 @@
 
 from genblaze_replicate.provider import ReplicateProvider
 
+from ._version import __version__  # noqa: F401 — re-exported
+
 __all__ = ["ReplicateProvider"]

genblaze_replicate-0.3.0/genblaze_replicate/_version.py

@@ -0,0 +1,16 @@
+"""``genblaze-replicate`` package version — single source of truth via importlib.metadata.
+
+Plan 5 Phase 1B — closes the version-drift class of bug across every
+genblaze connector. Reading from ``importlib.metadata`` makes the
+constant always equal to whatever wheel is installed; no manual edits
+per release.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__: str = version("genblaze-replicate")
+except PackageNotFoundError:  # pragma: no cover — editable dev installs
+    __version__ = "0.0.0+unknown"

genblaze_replicate-0.3.0/genblaze_replicate/provider.py

@@ -0,0 +1,399 @@
+"""ReplicateProvider — adapter for the Replicate API.
+
+Replicate hosts thousands of models. Slugs are free-form ``owner/name``
+strings — any of them is a valid input. The connector ships:
+
+* ``DiscoverySupport.NATIVE`` — Replicate's API can authoritatively answer
+  "is this slug live?" via ``GET /v1/models/{owner}/{name}``.
+* An empty registry with a permissive fallback. There are no per-slug
+  default specs because Replicate's surface is too large to enumerate.
+* A custom ``validate_model()`` that does a per-slug ``models.get()``
+  call (cached per-process, TTL-bounded) rather than enumerating the
+  full catalog. This is what NATIVE means for Replicate in practice.
+* A custom ``discover_models()`` that returns the *first page* of the
+  catalog as a documentation hint — enough to populate ``known()`` for
+  IDE autocomplete and conformance testing without paying the cost of
+  enumerating ~10k models on every cold start.
+
+**Pricing**: Replicate was previously hardcoded to
+``predict_time × 0.000225`` USD on the fallback spec. As of
+``genblaze-core 0.3.0`` the SDK no longer ships pricing — register the
+recipe yourself if you want compute-time cost tracking. See
+``docs/reference/pricing-recipes.md`` for the canonical Replicate recipe.
+
+Docs: https://replicate.com/docs/reference/http
+"""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+import threading
+import time
+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,
+    DiscoveryResult,
+    DiscoverySupport,
+    ModelRegistry,
+    ModelSpec,
+    ProviderCapabilities,
+    RetryPolicy,
+    ValidationOutcome,
+    ValidationResult,
+    ValidationSource,
+    route_by_media_type,
+    validate_asset_url,
+)
+from genblaze_core.providers.discovery import DEFAULT_TTL_SECONDS, _DiscoveryCache
+from genblaze_core.providers.retry import retry_after_from_response
+from genblaze_core.runnable.config import RunnableConfig
+
+from ._errors import map_replicate_error
+
+logger = logging.getLogger("genblaze.replicate")
+
+# Cap for the first-page discovery snapshot. Replicate's /v1/models
+# returns ~25 models per page; one page is enough to seed known() for
+# IDE/conformance purposes without enumerating the full catalog.
+_DISCOVERY_PAGE_LIMIT: int = 25
+
+# Replicate has no enumerable per-slug defaults. The fallback applies to
+# every model id with route_by_media_type wiring chain inputs to the
+# common ``image``/``video``/``audio`` keys most Replicate models accept.
+_FALLBACK_SPEC = ModelSpec(
+    model_id="*",
+    input_mapping=route_by_media_type({"image": "image", "video": "video", "audio": "audio"}),
+)
+
+
+class ReplicateProvider(BaseProvider):
+    """Provider adapter for Replicate (replicate.com)."""
+
+    name = "replicate"
+    discovery_support = DiscoverySupport.NATIVE
+    """Replicate exposes ``GET /v1/models/{owner}/{name}`` for authoritative
+    per-slug existence checks. The catalog itself is too large to enumerate
+    (~10k+ public models), so this provider validates per-slug rather than
+    snapshotting the full catalog."""
+
+    @classmethod
+    def create_registry(cls) -> ModelRegistry:
+        # Every model resolves through the fallback spec — Replicate's
+        # catalog is enumerated only via discovery, not shipped here.
+        # The discovery cache is wired per-instance in __init__ so each
+        # provider sees its own credentials' view of the catalog.
+        return ModelRegistry(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,
+        retry_policy: RetryPolicy | None = None,
+        probe_cache_ttl: float | None = None,
+        probe_cache_max_entries: int | None = None,
+    ):
+        # probe_cache_* are no-ops on this NATIVE-discovery provider; accepted
+        # for API uniformity so calling code can pass them to any provider
+        # without TypeError.
+        super().__init__(
+            models=models,
+            retry_policy=retry_policy,
+            probe_cache_ttl=probe_cache_ttl,
+            probe_cache_max_entries=probe_cache_max_entries,
+        )
+        self.poll_interval = poll_interval
+        self._client: Any = None
+        self._api_token = api_token
+        self._http_timeout = http_timeout
+        # Per-slug authoritative-validation cache. Stored as
+        # ``slug → (fetched_monotonic, ValidationResult)`` so we honor a TTL
+        # without re-issuing per-slug GETs on every Pipeline.run(). RLock
+        # keeps concurrent ``validate_model`` callers from racing on the
+        # cache writes; reads are fast-path lockless once populated.
+        self._validation_cache: dict[str, tuple[float, ValidationResult]] = {}
+        self._validation_lock = threading.RLock()
+        self._validation_ttl: float = DEFAULT_TTL_SECONDS
+        # Wire a discovery cache for the first-page snapshot. The fetcher
+        # closes over ``self`` so it picks up the (possibly-late-bound)
+        # ``self._client``.
+        self._models._discovery_cache = _DiscoveryCache(
+            self._fetch_first_page,
+            default_max_age_seconds=DEFAULT_TTL_SECONDS,
+        )
+
+    # --- catalog discovery & validation ------------------------------------
+
+    def _fetch_first_page(self) -> DiscoveryResult:
+        """Fetcher backing ``discover_models`` — first page of /v1/models.
+
+        Replicate's full catalog is too large to enumerate; one page is
+        enough to seed ``known()`` for IDE / conformance purposes. The
+        authoritative per-slug check lives in ``validate_model``.
+        """
+        try:
+            client = self._get_client()
+            page = client.models.list()
+            slugs: set[str] = set()
+            results = getattr(page, "results", None) or list(page)
+            for model in results[:_DISCOVERY_PAGE_LIMIT]:
+                owner = getattr(model, "owner", None)
+                name = getattr(model, "name", None)
+                if owner and name:
+                    slugs.add(f"{owner}/{name}")
+            return DiscoveryResult.ok(slugs, source_url="https://api.replicate.com/v1/models")
+        except Exception as exc:
+            logger.warning("Replicate discover_models first-page fetch failed: %s", exc)
+            return DiscoveryResult.failed(
+                f"first-page enumeration failed: {exc}",
+                source_url="https://api.replicate.com/v1/models",
+            )
+
+    def discover_models(
+        self,
+        *,
+        max_age_seconds: float | None = ...,  # type: ignore[assignment]
+    ) -> DiscoveryResult:
+        """Return the first-page snapshot of Replicate's catalog.
+
+        This is intentionally not exhaustive — Replicate hosts thousands
+        of models, and ``known()`` is documentation-grade, not a
+        contract. For authoritative existence checks, use
+        ``validate_model(slug)``, which does a per-slug ``models.get()``.
+        """
+        cache = self._models._discovery_cache
+        assert cache is not None  # wired in __init__
+        if max_age_seconds is ...:  # type: ignore[comparison-overlap]
+            return cache.get()
+        return cache.get(max_age_seconds=max_age_seconds)
+
+    def validate_model(self, model_id: str, *, refresh: bool = False) -> ValidationResult:
+        """Authoritative per-slug existence check.
+
+        Replicate's per-model GET is cheap (one round-trip, no token spend)
+        and returns 404 for missing slugs. We cache the result per-slug
+        with a TTL so successive ``Pipeline.run()`` invocations don't
+        re-fetch. ``refresh=True`` evicts the cache entry first.
+
+        Falls back to the base ``validate_model`` flow when the slug is
+        user-registered or matches a registered family — those layers are
+        already authoritative without a network call.
+        """
+        # Defer to the base class first — user-registered specs and
+        # family matches with cached discovery hits don't need a probe.
+        base_result = self._models.validate(model_id, discovery_support=self.discovery_support)
+        if (
+            base_result.outcome is ValidationOutcome.OK_AUTHORITATIVE
+            and base_result.source is not ValidationSource.DISCOVERY
+        ):
+            # USER or PROBE-source authoritative answer — no network needed.
+            return base_result
+
+        if refresh:
+            with self._validation_lock:
+                self._validation_cache.pop(model_id, None)
+        else:
+            cached = self._lookup_validation_cache(model_id)
+            if cached is not None:
+                return cached
+
+        result = self._authoritative_lookup(model_id)
+        with self._validation_lock:
+            self._validation_cache[model_id] = (time.monotonic(), result)
+        return result
+
+    def _lookup_validation_cache(self, model_id: str) -> ValidationResult | None:
+        with self._validation_lock:
+            entry = self._validation_cache.get(model_id)
+            if entry is None:
+                return None
+            fetched_at, result = entry
+            if (time.monotonic() - fetched_at) > self._validation_ttl:
+                # Expired — evict and force a fresh lookup.
+                del self._validation_cache[model_id]
+                return None
+            return result
+
+    def _authoritative_lookup(self, model_id: str) -> ValidationResult:
+        """Single-slug GET against /v1/models/{owner}/{name}.
+
+        Translates the Replicate SDK's responses into ``ValidationResult``:
+
+        * Success → ``OK_AUTHORITATIVE`` (source PROBE — same shape a
+          PARTIAL provider's family.probe would produce).
+        * 404 / NotFound → ``NOT_FOUND``.
+        * Other errors → ``UNKNOWN_PERMISSIVE`` (we couldn't verify; let
+          the upstream call surface the real error if there is one).
+        """
+        try:
+            client = self._get_client()
+            client.models.get(model_id)
+        except Exception as exc:
+            err_code = map_replicate_error(exc)
+            if err_code is ProviderErrorCode.MODEL_ERROR:
+                return ValidationResult.not_found(
+                    ValidationSource.PROBE,
+                    detail=f"upstream returned not-found: {exc}",
+                )
+            logger.debug(
+                "Replicate validate_model probe inconclusive for %s: %s",
+                model_id,
+                exc,
+            )
+            return ValidationResult.unknown_permissive(detail=f"probe inconclusive: {exc}")
+        return ValidationResult.ok_authoritative(
+            ValidationSource.PROBE,
+            detail="confirmed via /v1/models/{owner}/{name}",
+        )
+
+    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),
+                retry_after=retry_after_from_response(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),
+                retry_after=retry_after_from_response(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,
+                )
+
+            # Replicate output shapes vary by model: str (single URL), list[str]
+            # (multi-asset), dict[str, str | list] (e.g. {"video": url,
+            # "subtitles": url} from text-to-video models with side-channels),
+            # or None (no output). Normalize to list[str].
+            raw_output = prediction.output
+            urls: list[str]
+            if raw_output is None:
+                urls = []
+            elif isinstance(raw_output, str):
+                urls = [raw_output]
+            elif isinstance(raw_output, list):
+                # Nested lists happen on batch-output models; flatten one level.
+                urls = []
+                for item in raw_output:
+                    if isinstance(item, str):
+                        urls.append(item)
+                    elif isinstance(item, list):
+                        urls.extend(str(u) for u in item if isinstance(u, (str, bytes)))
+            elif isinstance(raw_output, dict):
+                # Multi-channel outputs: keep only URL-shaped string values.
+                urls = [str(v) for v in raw_output.values() if isinstance(v, str)]
+            else:
+                raise ProviderError(
+                    f"Unexpected Replicate output shape "
+                    f"({type(raw_output).__name__}): {raw_output!r}",
+                    error_code=ProviderErrorCode.SERVER_ERROR,
+                )
+
+            for url_str in urls:
+                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),
+                retry_after=retry_after_from_response(exc),
+            ) from exc

{genblaze_replicate-0.2.2 → genblaze_replicate-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "genblaze-replicate"
-version = "0.2.2"
+version = "0.3.0"
 description = "Replicate provider adapter for genblaze"
 authors = [{name = "Jeronimo De Leon", email = "jdeleon@backblaze.com"}]
 readme = "README.md"
@@ -14,9 +14,16 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
     "Typing :: Typed",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia",
+    "Topic :: Software Development :: Libraries",
 ]
+keywords = ["genblaze", "ai", "media", "manifest", "provenance", "c2pa-ready", "genai", "pipeline", "replicate", "video", "image"]
+
 dependencies = [
-    "genblaze-core>=0.2.0,<0.3",
+    "genblaze-core>=0.3.0,<0.4",
     "replicate>=0.25",
 ]
 

genblaze_replicate-0.3.0/tests/test_catalog_decoupling.py

@@ -0,0 +1,100 @@
+"""Catalog-decoupling regression tests for ``genblaze-replicate``.
+
+Replicate is the proof-point for ``DiscoverySupport.NATIVE`` with an
+empty default registry: every slug routes through the permissive
+fallback spec, and the upstream catalog is enumerated dynamically via
+``client.models.list()`` (wired in ``__init__`` per-instance for
+auth-aware caches).
+
+This file pins the contract for that minimal surface so a future
+edit can't silently regress the post-decoupling shape.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from genblaze_core.providers import DiscoverySupport
+
+
+@pytest.fixture(autouse=True)
+def _patch_replicate_sdk():
+    """Avoid importing the real replicate SDK in tests."""
+    fake = MagicMock()
+    with patch.dict("sys.modules", {"replicate": fake}):
+        yield
+
+
+# --- DiscoverySupport declaration -----------------------------------------
+
+
+class TestDiscoverySupportDeclaration:
+    def test_native(self) -> None:
+        from genblaze_replicate import ReplicateProvider
+
+        assert ReplicateProvider.discovery_support is DiscoverySupport.NATIVE
+
+
+# --- Registry shape (no families, fallback only) --------------------------
+
+
+class TestRegistryShape:
+    def test_no_provider_families_shipped(self) -> None:
+        """Replicate is meta-vendor — every model on its hub is a valid
+        slug. The connector ships zero families and lets the upstream
+        catalog speak for itself via discovery."""
+        from genblaze_replicate import ReplicateProvider
+
+        provider = ReplicateProvider(api_token="test")
+        assert provider._models.families == ()
+
+    def test_arbitrary_slug_resolves_via_fallback(self) -> None:
+        """Any slug — known model, brand-new release, typo — resolves
+        through the fallback. Replicate's own API gates submit-time
+        liveness."""
+        from genblaze_replicate import ReplicateProvider
+
+        provider = ReplicateProvider(api_token="test")
+        for slug in (
+            "black-forest-labs/flux-schnell",
+            "stability-ai/sdxl",
+            "owner/brand-new-model",
+            "a-typo-slug",
+        ):
+            spec = provider._models.get(slug)
+            assert spec is not None, slug
+
+
+# --- Pricing-removed contract --------------------------------------------
+
+
+class TestPricingPhaseOut:
+    def test_fallback_spec_carries_no_pricing(self) -> None:
+        """The connector's fallback spec ships with ``pricing=None``;
+        cost is user-registered via ``register_pricing``."""
+        from genblaze_replicate import ReplicateProvider
+
+        provider = ReplicateProvider(api_token="test")
+        spec = provider._models.get("any/slug")
+        assert spec.pricing is None
+
+
+# --- Cross-provider isolation --------------------------------------------
+
+
+class TestCrossProviderIsolation:
+    def test_replicate_does_not_match_other_provider_slugs(self) -> None:
+        """Replicate has no families — ``match_family`` returns None
+        for any slug; nothing matches, including slugs that look like
+        another provider's catalog."""
+        from genblaze_replicate import ReplicateProvider
+
+        provider = ReplicateProvider(api_token="test")
+        for slug in (
+            "veo-3.0-generate-001",
+            "imagen-3.0-generate-002",
+            "tts-1",
+            "ray-2",
+        ):
+            assert provider._models.match_family(slug) is None, slug

{genblaze_replicate-0.2.2 → genblaze_replicate-0.3.0}/tests/test_replicate_provider.py

@@ -7,8 +7,9 @@ from typing import Any
 from unittest.mock import MagicMock
 
 import pytest
-from genblaze_core.models.enums import ProviderErrorCode
+from genblaze_core.models.enums import Modality, ProviderErrorCode
 from genblaze_core.models.step import Step
+from genblaze_core.providers import ModelSpec
 from genblaze_core.testing import ProviderComplianceTests
 from genblaze_replicate._errors import map_replicate_error
 from genblaze_replicate.provider import ReplicateProvider
@@ -310,8 +311,12 @@ def test_fetch_output_rejects_schemeless_url():
         provider.fetch_output("pred-abc123", step)
 
 
-def test_cost_tracked_from_metrics():
-    """Cost is computed from prediction.metrics.predict_time."""
+def test_cost_none_by_default():
+    """As of genblaze-core 0.3.0 the SDK no longer ships pricing for
+    Replicate. ``cost_usd`` is ``None`` unless the user has registered
+    a pricing strategy via ``provider.models.register_pricing()``.
+    See ``docs/reference/pricing-recipes.md``.
+    """
     provider = ReplicateProvider(api_token="test-token")
     mock_client = MagicMock()
     pred = FakePrediction()
@@ -320,6 +325,33 @@ def test_cost_tracked_from_metrics():
     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_cost_tracked_with_user_registered_pricing():
+    """User-registered compute-time pricing flows through the same path."""
+    from genblaze_core.providers import per_response_metric
+
+    def compute_time_cost(ctx):
+        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
+        return float(predict_time) * 0.000225
+
+    provider = ReplicateProvider(api_token="test-token")
+    provider.models.register_pricing("test/model", per_response_metric(compute_time_cost))
+    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
@@ -327,8 +359,11 @@ def test_cost_tracked_from_metrics():
 
 
 def test_cost_none_without_metrics():
-    """Cost stays None when prediction has no metrics."""
+    """Cost stays None when prediction has no metrics, even with pricing registered."""
+    from genblaze_core.providers import per_response_metric
+
     provider = ReplicateProvider(api_token="test-token")
+    provider.models.register_pricing("test/model", per_response_metric(lambda ctx: 0.0))
     mock_client = MagicMock()
     pred = FakePrediction()
     # No metrics attribute
@@ -337,7 +372,9 @@ def test_cost_none_without_metrics():
 
     step = _make_step()
     result = provider.fetch_output("pred-abc123", step)
-    assert result.cost_usd is None
+    # The strategy returns 0.0 if metrics are absent — but we registered
+    # one that returns 0.0 unconditionally. Verify the pricing path runs.
+    assert result.cost_usd == pytest.approx(0.0)
 
 
 def test_token_not_in_provider_payload():
@@ -357,6 +394,137 @@ def test_token_not_in_provider_payload():
     assert "r8_secret_token_123" not in payload_str
 
 
+# --- Catalog-decoupling: discovery + per-slug validation ---
+
+
+def _make_model(owner: str, name: str):
+    """Minimal fake of a Replicate ``Model`` object."""
+    m = MagicMock()
+    m.owner = owner
+    m.name = name
+    return m
+
+
+def test_discovery_support_native():
+    """Replicate is the proof-point for NATIVE discovery in PR #3."""
+    from genblaze_core.providers import DiscoverySupport
+
+    assert ReplicateProvider.discovery_support is DiscoverySupport.NATIVE
+
+
+def test_discover_models_returns_first_page():
+    """``discover_models`` snapshots the first page of /v1/models — enough
+    to seed ``known()`` without enumerating the entire catalog."""
+    from genblaze_core.providers import DiscoveryStatus
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    page = MagicMock()
+    page.results = [
+        _make_model("black-forest-labs", "flux-schnell"),
+        _make_model("stability-ai", "sdxl"),
+        _make_model("meta", "llama-3"),
+    ]
+    mock_client.models.list.return_value = page
+    provider._client = mock_client
+
+    result = provider.discover_models()
+    assert result.status is DiscoveryStatus.OK
+    assert "black-forest-labs/flux-schnell" in result.slugs
+    assert "stability-ai/sdxl" in result.slugs
+    assert result.source_url == "https://api.replicate.com/v1/models"
+
+
+def test_discover_models_failure_returns_failed():
+    """A failed list call surfaces as ``DiscoveryStatus.FAILED`` — never
+    raises into the caller, never poisons the cache."""
+    from genblaze_core.providers import DiscoveryStatus
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.models.list.side_effect = RuntimeError("boom")
+    provider._client = mock_client
+
+    result = provider.discover_models()
+    assert result.status is DiscoveryStatus.FAILED
+    assert "boom" in (result.detail or "")
+
+
+def test_validate_model_authoritative_via_models_get():
+    """A live slug returns ``OK_AUTHORITATIVE`` (source PROBE) via
+    ``client.models.get()`` — the cheap-existence-check that Replicate
+    supports authoritatively."""
+    from genblaze_core.providers import ValidationOutcome, ValidationSource
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.models.get.return_value = _make_model("owner", "live-model")
+    provider._client = mock_client
+
+    result = provider.validate_model("owner/live-model")
+    assert result.outcome is ValidationOutcome.OK_AUTHORITATIVE
+    assert result.source is ValidationSource.PROBE
+
+
+def test_validate_model_not_found_via_models_get():
+    """A 404-class error from ``client.models.get()`` surfaces as
+    ``NOT_FOUND``. The Pipeline preflight phase raises on this outcome
+    before any prediction is created."""
+    from genblaze_core.providers import ValidationOutcome, ValidationSource
+
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.models.get.side_effect = RuntimeError("404 model not found")
+    provider._client = mock_client
+
+    result = provider.validate_model("owner/dead-model")
+    assert result.outcome is ValidationOutcome.NOT_FOUND
+    assert result.source is ValidationSource.PROBE
+
+
+def test_validate_model_caches_result():
+    """Per-slug validation cache memoizes the per-slug GET so successive
+    Pipeline runs don't re-fetch."""
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.models.get.return_value = _make_model("owner", "x")
+    provider._client = mock_client
+
+    provider.validate_model("owner/x")
+    provider.validate_model("owner/x")
+    provider.validate_model("owner/x")
+
+    assert mock_client.models.get.call_count == 1
+
+
+def test_validate_model_refresh_evicts_cache():
+    """``refresh=True`` forces a fresh per-slug GET."""
+    provider = ReplicateProvider(api_token="test-token")
+    mock_client = MagicMock()
+    mock_client.models.get.return_value = _make_model("owner", "x")
+    provider._client = mock_client
+
+    provider.validate_model("owner/x")
+    provider.validate_model("owner/x", refresh=True)
+    assert mock_client.models.get.call_count == 2
+
+
+def test_validate_model_user_registered_skips_probe():
+    """A user-registered exact spec is authoritative without a network
+    round-trip — the per-slug probe should not fire."""
+    from genblaze_core.providers import ValidationOutcome, ValidationSource
+
+    provider = ReplicateProvider(api_token="test-token")
+    provider.models.register(ModelSpec(model_id="owner/local", modality=Modality.IMAGE))
+    mock_client = MagicMock()
+    provider._client = mock_client
+
+    result = provider.validate_model("owner/local")
+    assert result.outcome is ValidationOutcome.OK_AUTHORITATIVE
+    assert result.source is ValidationSource.USER
+    mock_client.models.get.assert_not_called()
+
+
 # --- Compliance harness ---
 
 

genblaze_replicate-0.2.2/genblaze_replicate/provider.py

@@ -1,227 +0,0 @@
-"""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.providers.retry import retry_after_from_response
-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),
-                retry_after=retry_after_from_response(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),
-                retry_after=retry_after_from_response(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,
-                )
-
-            # Replicate output shapes vary by model: str (single URL), list[str]
-            # (multi-asset), dict[str, str | list] (e.g. {"video": url,
-            # "subtitles": url} from text-to-video models with side-channels),
-            # or None (no output). Normalize to list[str].
-            raw_output = prediction.output
-            urls: list[str]
-            if raw_output is None:
-                urls = []
-            elif isinstance(raw_output, str):
-                urls = [raw_output]
-            elif isinstance(raw_output, list):
-                # Nested lists happen on batch-output models; flatten one level.
-                urls = []
-                for item in raw_output:
-                    if isinstance(item, str):
-                        urls.append(item)
-                    elif isinstance(item, list):
-                        urls.extend(str(u) for u in item if isinstance(u, (str, bytes)))
-            elif isinstance(raw_output, dict):
-                # Multi-channel outputs: keep only URL-shaped string values.
-                urls = [str(v) for v in raw_output.values() if isinstance(v, str)]
-            else:
-                raise ProviderError(
-                    f"Unexpected Replicate output shape "
-                    f"({type(raw_output).__name__}): {raw_output!r}",
-                    error_code=ProviderErrorCode.SERVER_ERROR,
-                )
-
-            for url_str in urls:
-                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),
-                retry_after=retry_after_from_response(exc),
-            ) from exc