dominus-sdk-python 9.0.4__tar.gz → 9.0.6__tar.gz

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 9.0.4
+Version: 9.0.6
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License-Expression: LicenseRef-Proprietary
@@ -48,7 +48,7 @@ cleanup audit is `docs/janitor/2026-08-04-sdk-python-cleanup-audit.md`.
 - Gateway-scoped client mode for MCP and other user-JWT sessions
 - Transport compatibility for wrapped `{success,data}` responses and unwrapped Warden/control-plane success objects
 - Local helpers for JWT verification, trace propagation, retries, and console capture
-- Current package version: `9.0.4`
+- Current package version: `9.0.5`
 
 ## Install
 

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/README.md

@@ -15,7 +15,7 @@ cleanup audit is `docs/janitor/2026-08-04-sdk-python-cleanup-audit.md`.
 - Gateway-scoped client mode for MCP and other user-JWT sessions
 - Transport compatibility for wrapped `{success,data}` responses and unwrapped Warden/control-plane success objects
 - Local helpers for JWT verification, trace propagation, retries, and console capture
-- Current package version: `9.0.4`
+- Current package version: `9.0.5`
 
 ## Install
 

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus/__init__.py

@@ -160,12 +160,24 @@ from .helpers.trace import (
 # Export error classes
 from .errors import (
     DominusError,
+    # v1 aliases (preserved — deprecated in v2, removed in v3 per ADR 0010)
     AuthenticationError,
     AuthorizationError,
-    NotFoundError,
     ValidationError,
-    ConflictError,
     ServiceError,
+    # Per-kind canonical subclasses (Seams fork 6, ADR 0010)
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    ValidationFailedError,
+    ConflictError,
+    RateLimitedError,
+    UpstreamUnavailableError,
+    InternalError,
+    TimeoutError,
+    CanceledError,
+    UnsupportedVersionError,
+    # Stash subclasses
     StashBookmarkArtifactNotFound,
     StashBookmarkInvalidVersionRef,
     StashBookmarkDuplicateName,
@@ -178,7 +190,7 @@ from .errors import (
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "9.0.4"
+__version__ = "9.0.6"
 __all__ = [
     # Main SDK instance
     "dominus",
@@ -262,12 +274,23 @@ __all__ = [
     "with_trace",
     # Error classes
     "DominusError",
+    # v1 aliases (preserved)
     "AuthenticationError",
     "AuthorizationError",
-    "NotFoundError",
     "ValidationError",
-    "ConflictError",
     "ServiceError",
+    # Per-kind canonical subclasses
+    "UnauthorizedError",
+    "ForbiddenError",
+    "NotFoundError",
+    "ValidationFailedError",
+    "ConflictError",
+    "RateLimitedError",
+    "UpstreamUnavailableError",
+    "InternalError",
+    "TimeoutError",
+    "CanceledError",
+    "UnsupportedVersionError",
     "StashBookmarkArtifactNotFound",
     "StashBookmarkInvalidVersionRef",
     "StashBookmarkDuplicateName",

dominus_sdk_python-9.0.6/dominus/contract/__init__.py

@@ -0,0 +1,10 @@
+"""Python SDK contract module (S-4.8): envelope + projection helpers."""
+from .envelope import python_envelope, python_raise_for_status
+from .projections import Projections, python_projections
+
+__all__ = [
+    "Projections",
+    "python_envelope",
+    "python_projections",
+    "python_raise_for_status",
+]

dominus_sdk_python-9.0.6/dominus/contract/envelope.py

@@ -0,0 +1,23 @@
+"""Surface-adapter view of the canonical error envelope.
+
+Wraps existing ``DominusError.to_dict()`` / ``raise_for_status`` — no
+wire-shape change. Existing call sites stay on those APIs directly.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from dominus.errors import DominusError, raise_for_status
+
+
+def python_envelope(error: DominusError) -> Dict[str, Any]:
+    return error.to_dict()
+
+
+def python_raise_for_status(
+    status_code: int,
+    message: str,
+    details: Optional[Dict[str, Any]] = None,
+    endpoint: Optional[str] = None,
+) -> None:
+    raise_for_status(status_code, message, details, endpoint)

dominus_sdk_python-9.0.6/dominus/contract/projections.py

@@ -0,0 +1,22 @@
+"""Typed passthrough builder for per-surface name projections (ADR-0009).
+
+This SDK has no projection catalog; the helper accepts a projections
+object and returns it unchanged.
+"""
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class Projections(TypedDict, total=False):
+    gateway_path: str
+    sdk_python: str
+    sdk_nodejs: str
+    error_code_prefix: str
+    log_event_name: str
+    timeline_event_type: str
+    deploy_class: str
+
+
+def python_projections(projections: Projections) -> Projections:
+    return projections

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus/namespaces/artifacts.py

@@ -1,5 +1,11 @@
 """
-Artifacts Namespace - Temporary artifact storage.
+Artifacts Namespace - temporary and addressed artifact storage.
+
+Positioning: this is the **escape hatch** for direct ``ar://`` addressed
+artifact workflows — use it when you already hold a canonical ``ar://`` ref.
+For new code, prefer a Stash ``artifact-v2``-backed kind (e.g. ``artifact-v1``)
+via ``dominus.stash.*``, the primary storage surface (the Two-Layer Storage
+Rule). These addressed helpers are a building block under Stash, not deprecated.
 
 Provides auto-tiered artifact storage (Redis < 1MB, B2 >= 1MB)
 with TTL-based expiration. Routes through gateway to artifact-worker.

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus/namespaces/browser.py

@@ -162,7 +162,12 @@ class BrowserNamespace:
         )
 
     async def get_run_status(self, run_id: str, *, timeout: float = 30.0) -> Dict[str, Any]:
-        """Read browser run runtime state. ``GET /api/browser/runs/{run_id}/status``."""
+        """Read browser run runtime state. ``GET /api/browser/runs/{run_id}/status``.
+
+        The envelope may carry an additive ``result_stash_ref`` (Stash palette
+        ``artifact`` selector) alongside the legacy ``result_artifact_ref``; it is
+        present only when a best-effort Stash dual-write succeeded.
+        """
         if not run_id:
             raise ValueError("run_id is required")
         return await self._get(

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus/namespaces/stash.py

@@ -1,5 +1,9 @@
 """
-Stash Namespace - per-scope durable items (credentials + configs).
+Stash Namespace - the primary kind-addressed storage surface.
+
+Store named-kind data here and let the kind registry pick the backend — you
+address items by (kind, scope, key), not by physical storage. ``ar://``
+addressed artifact workflows remain the escape hatch for foreign refs.
 
 Routes through ``/svc/stash/*`` on the Dominus gateway. The stash worker
 stores items in each project's ``stash.*`` schema and transparently falls
@@ -53,6 +57,18 @@ ManagedTableOperator = Literal[
     "after",
 ]
 
+# Live stash kind backends. The kind registry dispatches each registered kind
+# to exactly one of these; `artifact-v2` and `journal` are the newer additions
+# that previously had no typed surface in this SDK.
+StashBackend = Literal[
+    "db-row",
+    "b2-versioned-bytes",
+    "b2-pointer-text",
+    "redis-ttl",
+    "artifact-v2",
+    "journal",
+]
+
 
 class _ManagedTableFieldOptional(TypedDict, total=False):
     required: bool
@@ -536,6 +552,7 @@ class StashNamespace:
         self,
         *,
         kind: str,
+        backend: Optional[StashBackend] = None,
         is_sensitive: Optional[bool] = None,
         value_schema: Optional[Dict[str, Any]] = None,
         default_rotation_days: Optional[int] = None,
@@ -544,6 +561,8 @@ class StashNamespace:
     ) -> Dict[str, Any]:
         """Register or update a kind in stash.kind_registry. Admin-scoped."""
         body: Dict[str, Any] = {"kind": kind}
+        if backend is not None:
+            body["backend"] = backend
         if is_sensitive is not None:
             body["is_sensitive"] = is_sensitive
         if value_schema is not None:

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus/start.py

@@ -472,7 +472,7 @@ class Dominus:
             if not isinstance(error_details, dict):
                 error_details = {}
             for src in (error_payload, nested_err):
-                for key in ("code", "category", "retryable", "trace_id", "request_id"):
+                for key in ("kind", "code", "category", "retryable", "trace_id", "request_id", "correlation_id", "cause"):
                     if key in src and key not in error_details:
                         error_details[key] = src[key]
             raise_for_status(
@@ -502,7 +502,7 @@ class Dominus:
             error_details = result.get("details")
             if not isinstance(error_details, dict):
                 error_details = {}
-            for key in ("code", "category", "retryable", "trace_id", "request_id"):
+            for key in ("kind", "code", "category", "retryable", "trace_id", "request_id", "correlation_id", "cause"):
                 if key in result:
                     error_details[key] = result[key]
             raise DominusError(str(error_msg), details=error_details, endpoint=endpoint)

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 9.0.4
+Version: 9.0.6
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License-Expression: LicenseRef-Proprietary
@@ -48,7 +48,7 @@ cleanup audit is `docs/janitor/2026-08-04-sdk-python-cleanup-audit.md`.
 - Gateway-scoped client mode for MCP and other user-JWT sessions
 - Transport compatibility for wrapped `{success,data}` responses and unwrapped Warden/control-plane success objects
 - Local helpers for JWT verification, trace propagation, retries, and console capture
-- Current package version: `9.0.4`
+- Current package version: `9.0.5`
 
 ## Install
 

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/dominus_sdk_python.egg-info/SOURCES.txt

@@ -6,6 +6,9 @@ dominus/py.typed
 dominus/start.py
 dominus/config/__init__.py
 dominus/config/endpoints.py
+dominus/contract/__init__.py
+dominus/contract/envelope.py
+dominus/contract/projections.py
 dominus/helpers/__init__.py
 dominus/helpers/auth.py
 dominus/helpers/cache.py
@@ -52,9 +55,11 @@ dominus_sdk_python.egg-info/top_level.txt
 tests/test_auth.py
 tests/test_authority_public_vocabulary.py
 tests/test_browser_namespace.py
+tests/test_contract.py
 tests/test_control_plane_namespaces.py
 tests/test_error_recovery_action.py
 tests/test_errors.py
+tests/test_errors_aliases.py
 tests/test_flat_commands.py
 tests/test_health.py
 tests/test_logs.py

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "9.0.4"
+version = "9.0.6"
 description = "Python SDK for the Dominus gateway-first platform"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

dominus_sdk_python-9.0.6/tests/test_contract.py

@@ -0,0 +1,70 @@
+from dominus.errors import DominusError, raise_for_status
+from dominus.contract import python_envelope, python_projections, python_raise_for_status
+
+
+def test_python_envelope_wraps_to_dict_without_changing_wire_shape():
+    error = DominusError(
+        "Missing resource",
+        status_code=404,
+        details={
+            "code": "authority.resource.not_found",
+            "kind": "not_found",
+            "request_id": "req-python-contract-1",
+            "correlation_id": "corr-python-contract-1",
+        },
+        endpoint="/svc/authority/runs/status",
+    )
+
+    from_class = error.to_dict()
+    from_contract = python_envelope(error)
+
+    assert from_contract == from_class
+    assert from_contract["kind"] == "not_found"
+    assert from_contract["code"] == "authority.resource.not_found"
+    assert from_contract["request_id"] == "req-python-contract-1"
+    assert from_contract["http_status"] == 404
+    assert from_contract["envelope_version"] == "1"
+
+
+def test_python_raise_for_status_wraps_existing_raise_for_status():
+    try:
+        python_raise_for_status(
+            401,
+            "bad token",
+            {"kind": "unauthorized", "code": "kernel.auth.token_invalid"},
+        )
+    except DominusError as error:
+        assert error.kind == "unauthorized"
+        assert python_envelope(error) == error.to_dict()
+    else:
+        raise AssertionError("python_raise_for_status should raise DominusError")
+
+
+def test_python_raise_for_status_matches_raise_for_status_class():
+    raised = None
+    wrapped = None
+    try:
+        raise_for_status(404, "gone")
+    except DominusError as error:
+        raised = type(error)
+    try:
+        python_raise_for_status(404, "gone")
+    except DominusError as error:
+        wrapped = type(error)
+    assert raised is not None and raised is wrapped
+
+
+def test_python_projections_is_typed_passthrough_builder():
+    incoming = {
+        "gateway_path": "/svc/authority/runs/ensure",
+        "sdk_python": "dominus.workflow.ensure",
+        "sdk_nodejs": "dominus.workflow.ensure",
+        "error_code_prefix": "authority.",
+        "log_event_name": "authority.run.ensure",
+        "timeline_event_type": "authority.run.ensured",
+        "deploy_class": "worker_ga",
+    }
+
+    out = python_projections(incoming)
+    assert out is incoming
+    assert out == incoming

dominus_sdk_python-9.0.6/tests/test_errors_aliases.py

@@ -0,0 +1,277 @@
+"""
+Test per-kind canonical error subclasses and v1 alias compatibility.
+
+Seams fork 6 (ADR 0010): DominusError base + 11 per-kind subclasses;
+existing class names preserved as aliases in v1.
+"""
+import pytest
+from dominus.errors import (
+    DominusError,
+    # v1 aliases (preserved)
+    AuthenticationError,
+    AuthorizationError,
+    ValidationError,
+    ServiceError,
+    ConnectionError,
+    SecureTableError,
+    # Per-kind canonical subclasses
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    ValidationFailedError,
+    ConflictError,
+    RateLimitedError,
+    UpstreamUnavailableError,
+    InternalError,
+    TimeoutError,
+    CanceledError,
+    UnsupportedVersionError,
+    # Stash subclasses
+    StashBookmarkArtifactNotFound,
+    StashBookmarkInvalidVersionRef,
+    StashBookmarkDuplicateName,
+    StashBookmarkUpstreamRejected,
+    StashWatchInvalidWebhookUrl,
+    StashWatchUpstreamRejected,
+    StashWatchNotFound,
+    raise_for_status,
+)
+
+CANONICAL_KINDS = [
+    "unauthorized",
+    "forbidden",
+    "not_found",
+    "validation_failed",
+    "conflict",
+    "rate_limited",
+    "upstream_unavailable",
+    "internal",
+    "timeout",
+    "canceled",
+    "unsupported_version",
+]
+
+PER_KIND_CLASSES = [
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    ValidationFailedError,
+    ConflictError,
+    RateLimitedError,
+    UpstreamUnavailableError,
+    InternalError,
+    TimeoutError,
+    CanceledError,
+    UnsupportedVersionError,
+]
+
+
+class TestPerKindSubclasses:
+    """Each canonical kind has a DominusError subclass with the correct kind."""
+
+    def test_all_kinds_have_subclass(self):
+        kind_map = {cls.kind: cls for cls in PER_KIND_CLASSES}
+        for kind in CANONICAL_KINDS:
+            assert kind in kind_map, f"Missing subclass for kind '{kind}'"
+
+    def test_each_subclass_has_kind_attribute(self):
+        for cls in PER_KIND_CLASSES:
+            assert cls.kind in CANONICAL_KINDS, f"{cls.__name__}.kind = {cls.kind!r} not in canonical kinds"
+
+    def test_each_subclass_is_dominus_error(self):
+        for cls in PER_KIND_CLASSES:
+            assert issubclass(cls, DominusError), f"{cls.__name__} is not a DominusError subclass"
+
+    def test_instance_kind_matches_class_kind(self):
+        for cls in PER_KIND_CLASSES:
+            err = cls("test")
+            assert err.kind == cls.kind, f"{cls.__name__} instance kind mismatch: {err.kind!r} != {cls.kind!r}"
+
+
+class TestV1Aliases:
+    """v1 alias class names resolve to the canonical per-kind subclass."""
+
+    def test_authentication_error_is_unauthorized(self):
+        assert issubclass(AuthenticationError, UnauthorizedError)
+        err = AuthenticationError()
+        assert isinstance(err, UnauthorizedError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "unauthorized"
+
+    def test_authorization_error_is_forbidden(self):
+        assert issubclass(AuthorizationError, ForbiddenError)
+        err = AuthorizationError()
+        assert isinstance(err, ForbiddenError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "forbidden"
+
+    def test_validation_error_is_validation_failed(self):
+        assert issubclass(ValidationError, ValidationFailedError)
+        err = ValidationError()
+        assert isinstance(err, ValidationFailedError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "validation_failed"
+
+    def test_service_error_is_upstream_unavailable(self):
+        assert issubclass(ServiceError, UpstreamUnavailableError)
+        err = ServiceError()
+        assert isinstance(err, UpstreamUnavailableError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "upstream_unavailable"
+
+    def test_connection_error_is_upstream_unavailable(self):
+        assert issubclass(ConnectionError, UpstreamUnavailableError)
+        err = ConnectionError()
+        assert isinstance(err, UpstreamUnavailableError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "upstream_unavailable"
+
+    def test_secure_table_error_is_forbidden(self):
+        assert issubclass(SecureTableError, ForbiddenError)
+        err = SecureTableError()
+        assert isinstance(err, ForbiddenError)
+        assert isinstance(err, DominusError)
+        assert err.kind == "forbidden"
+
+    def test_existing_catch_sites_still_work(self):
+        """Catching by old name still catches the canonical subclass instance."""
+        err = UnauthorizedError("bad token")
+        # Old catch pattern
+        try:
+            raise err
+        except AuthenticationError as e:
+            assert e.kind == "unauthorized"
+            assert e.message == "bad token"
+
+
+class TestStashSubclasses:
+    """Stash subclasses map to canonical per-kind bases."""
+
+    def test_stash_bookmark_not_found(self):
+        assert issubclass(StashBookmarkArtifactNotFound, NotFoundError)
+        assert StashBookmarkArtifactNotFound().kind == "not_found"
+
+    def test_stash_bookmark_invalid_ref(self):
+        assert issubclass(StashBookmarkInvalidVersionRef, ValidationFailedError)
+        assert StashBookmarkInvalidVersionRef().kind == "validation_failed"
+
+    def test_stash_bookmark_duplicate(self):
+        assert issubclass(StashBookmarkDuplicateName, ConflictError)
+        assert StashBookmarkDuplicateName().kind == "conflict"
+
+    def test_stash_bookmark_upstream(self):
+        assert issubclass(StashBookmarkUpstreamRejected, UpstreamUnavailableError)
+        assert StashBookmarkUpstreamRejected().kind == "upstream_unavailable"
+
+    def test_stash_watch_invalid_url(self):
+        assert issubclass(StashWatchInvalidWebhookUrl, ValidationFailedError)
+        assert StashWatchInvalidWebhookUrl().kind == "validation_failed"
+
+    def test_stash_watch_upstream(self):
+        assert issubclass(StashWatchUpstreamRejected, UpstreamUnavailableError)
+        assert StashWatchUpstreamRejected().kind == "upstream_unavailable"
+
+    def test_stash_watch_not_found(self):
+        assert issubclass(StashWatchNotFound, NotFoundError)
+        assert StashWatchNotFound().kind == "not_found"
+
+
+class TestRaiseForStatus:
+    """raise_for_status maps HTTP codes to canonical per-kind classes."""
+
+    def test_401_raises_unauthorized(self):
+        with pytest.raises(UnauthorizedError) as exc:
+            raise_for_status(401, "bad token")
+        assert exc.value.kind == "unauthorized"
+
+    def test_403_raises_forbidden(self):
+        with pytest.raises(ForbiddenError) as exc:
+            raise_for_status(403, "nope")
+        assert exc.value.kind == "forbidden"
+
+    def test_404_raises_not_found(self):
+        with pytest.raises(NotFoundError) as exc:
+            raise_for_status(404, "gone")
+        assert exc.value.kind == "not_found"
+
+    def test_400_raises_validation_failed(self):
+        with pytest.raises(ValidationFailedError) as exc:
+            raise_for_status(400, "bad input")
+        assert exc.value.kind == "validation_failed"
+
+    def test_409_raises_conflict(self):
+        with pytest.raises(ConflictError) as exc:
+            raise_for_status(409, "dup")
+        assert exc.value.kind == "conflict"
+
+    def test_429_raises_rate_limited(self):
+        with pytest.raises(RateLimitedError) as exc:
+            raise_for_status(429, "slow down")
+        assert exc.value.kind == "rate_limited"
+
+    def test_500_raises_upstream_unavailable(self):
+        with pytest.raises(UpstreamUnavailableError) as exc:
+            raise_for_status(500, "boom")
+        assert exc.value.kind == "upstream_unavailable"
+
+    def test_504_raises_timeout(self):
+        with pytest.raises(TimeoutError) as exc:
+            raise_for_status(504, "took too long")
+        assert exc.value.kind == "timeout"
+
+    def test_explicit_wire_kind_wins_over_status_mapping(self):
+        with pytest.raises(UnsupportedVersionError) as exc:
+            raise_for_status(
+                400,
+                "Unsupported API version",
+                {"kind": "unsupported_version", "code": "platform.api.unsupported_version"},
+            )
+        assert exc.value.kind == "unsupported_version"
+
+    def test_stash_code_dispatches_to_stash_subclass(self):
+        with pytest.raises(StashBookmarkArtifactNotFound) as exc:
+            raise_for_status(404, "bookmark gone", {"code": "stash.bookmark.artifact_not_found"})
+        assert isinstance(exc.value, NotFoundError)
+        assert exc.value.kind == "not_found"
+
+
+class TestDominusErrorKind:
+    """DominusError base class carries kind and exposes it in to_dict."""
+
+    def test_default_kind_is_internal(self):
+        err = DominusError("generic")
+        assert err.kind == "internal"
+
+    def test_explicit_kind_overrides_default(self):
+        err = DominusError("custom", kind="timeout")
+        assert err.kind == "timeout"
+
+    def test_to_dict_includes_kind(self):
+        err = UnauthorizedError("nope")
+        d = err.to_dict()
+        assert d["kind"] == "unauthorized"
+
+    def test_to_dict_emits_canonical_wire_fields(self):
+        err = NotFoundError(
+            "Missing resource",
+            details={
+                "code": "authority.resource.not_found",
+                "request_id": "req-python-envelope-1",
+                "correlation_id": "corr-python-envelope-1",
+            },
+        )
+
+        envelope = err.to_dict()
+        assert {key: envelope.get(key) for key in (
+            "kind", "code", "message", "request_id", "correlation_id",
+            "retryable", "http_status", "envelope_version",
+        )} == {
+            "kind": "not_found",
+            "code": "authority.resource.not_found",
+            "message": "Missing resource",
+            "request_id": "req-python-envelope-1",
+            "correlation_id": "corr-python-envelope-1",
+            "retryable": False,
+            "http_status": 404,
+            "envelope_version": "1",
+        }

{dominus_sdk_python-9.0.4 → dominus_sdk_python-9.0.6}/tests/test_stash_artifact_facade.py

@@ -353,3 +353,72 @@ async def test_watch_invalid_webhook_url_raises_typed_exception(monkeypatch, sdk
 
     assert exc_info.value.code == "stash.watch.invalid_webhook_url"
     assert exc_info.value.endpoint == "/svc/stash/watch"
+
+
+@pytest.mark.asyncio
+async def test_register_kind_posts_backend(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {"kind": {"kind": "artifact", "backend": "artifact-v2"}}
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.stash.register_kind(
+        kind="artifact",
+        backend="artifact-v2",
+        is_sensitive=False,
+        description="versioned artifacts",
+    )
+
+    assert result == {"kind": "artifact", "backend": "artifact-v2"}
+    assert calls == [
+        {
+            "endpoint": "/svc/stash/kinds/register",
+            "body": {
+                "kind": "artifact",
+                "backend": "artifact-v2",
+                "is_sensitive": False,
+                "description": "versioned artifacts",
+            },
+            "use_gateway": True,
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_register_kind_omits_backend_when_unset(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {"kind": {"kind": "document"}}
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.stash.register_kind(kind="document")
+
+    assert result == {"kind": "document"}
+    assert calls == [
+        {
+            "endpoint": "/svc/stash/kinds/register",
+            "body": {"kind": "document"},
+            "use_gateway": True,
+        }
+    ]
+
+
+def test_stash_backend_literal_covers_live_backends():
+    from typing import get_args
+
+    from dominus.namespaces.stash import StashBackend
+
+    assert set(get_args(StashBackend)) == {
+        "db-row",
+        "b2-versioned-bytes",
+        "b2-pointer-text",
+        "redis-ttl",
+        "artifact-v2",
+        "journal",
+    }