synth-ai 0.18.1.dev594__tar.gz → 0.18.1.dev596__tar.gz

{synth_ai-0.18.1.dev594/synth_ai.egg-info → synth_ai-0.18.1.dev596}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.18.1.dev594
+Version: 0.18.1.dev596
 Summary: Python SDK and CLI for Synth Managed Research and Research Factory
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.18.1.dev594"
+version = "0.18.1.dev596"
 description = "Python SDK and CLI for Synth Managed Research and Research Factory"
 authors = [{name = "Synth AI", email = "josh@usesynth.ai"}]
 license = "MIT"

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/contracts/__init__.py

@@ -177,6 +177,13 @@ from synth_ai.sdk.research.contracts.factory_role_receipts import (
     FactoryRoleReceiptResponse,
     FactoryRoleReceiptRuntimeEvidence,
 )
+from synth_ai.sdk.research.contracts.failure import (
+    ActorFailureReason,
+    ManagedResearchFailureClassification,
+    ManagedResearchFailureFamily,
+    ManagedResearchFailureScope,
+    ManagedResearchFailureSeverity,
+)
 from synth_ai.sdk.research.contracts.image_releases import (
     ActorImageCapability,
     ActorRuntimeImageMaterialization,
@@ -199,6 +206,8 @@ from synth_ai.sdk.research.contracts.image_releases import (
     ImageReleaseUploadRequest,
     ImageReleaseUploadResponse,
     ImageUploadId,
+    RegistryActorRuntimeImageRegistration,
+    RegistryActorRuntimeImageRegistrationRequest,
     RuntimeImageReleaseArchiveResponse,
     RuntimeImageReleaseId,
     RuntimeImageReleaseListResponse,
@@ -476,6 +485,7 @@ def __getattr__(name: str) -> object:
 
 
 __all__ = [
+    "ActorFailureReason",
     "DataBindingCreateRequest",
     "DataBindingResponse",
     "DatasetRevisionContent",
@@ -513,6 +523,10 @@ __all__ = [
     "MagiDecisionReceiptResponse",
     "MagiDecisionRequest",
     "MagiMode",
+    "ManagedResearchFailureClassification",
+    "ManagedResearchFailureFamily",
+    "ManagedResearchFailureScope",
+    "ManagedResearchFailureSeverity",
     "ActivityActor",
     "ActivityActorState",
     "ActivityCursor",
@@ -545,6 +559,8 @@ __all__ = [
     "ActorRuntimeImageReleaseArchive",
     "ActorRuntimeImageReleaseDeclaration",
     "ActorRuntimeImageReleaseList",
+    "RegistryActorRuntimeImageRegistration",
+    "RegistryActorRuntimeImageRegistrationRequest",
     "BranchMode",
     "BranchResult",
     "BranchSpec",

synth_ai-0.18.1.dev596/synth_ai/sdk/research/contracts/failure.py

@@ -0,0 +1,173 @@
+"""Public Managed Research failure vocabulary and wire contract."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class ActorFailureReason(StrEnum):
+    ACTOR_STARTUP_RETRY_BUDGET_EXHAUSTED = "actor_startup_retry_budget_exhausted"
+    TASK_BLOCKED = "task_blocked"
+    TASK_FAILED = "task_failed"
+    RUN_FAILED = "run_failed"
+    ORCHESTRATOR_SESSION_START_FAILED = "orchestrator_session_start_failed"
+    ORCHESTRATOR_SESSION_FAILED = "orchestrator_session_failed"
+    TASK_CLAIM_MATERIALIZATION_FAILED = "task_claim_materialization_failed"
+    CLAIMED_ACTOR_MISSING_TASK_BINDING = "claimed_actor_missing_task_binding"
+    WORKER_HOST_CLAIMED_NON_TASK_ACTOR = "worker_host_claimed_non_task_actor"
+    WORKER_HOST_ACTOR_RUN_MISSING = "worker_host_actor_run_missing"
+    WORKER_HOST_CLAIMED_ACTOR_TASK_MISSING = "worker_host_claimed_actor_task_missing"
+    TASK_ALREADY_TERMINAL = "task_already_terminal"
+    DB_POOL_PRESSURE = "db_pool_pressure"
+    CONTROL_PLANE_PRESSURE = "control_plane_pressure"
+    PARTICIPANT_START_BACKPRESSURE = "participant_start_backpressure"
+    PARTICIPANT_SYNC_DEFERRED_UNCONSUMED = "participant_sync_deferred_unconsumed"
+    TERMINAL_TRANSITION_DEFERRED_UNCONSUMED = "terminal_transition_deferred_unconsumed"
+    PARTICIPANT_LIVE_CAPACITY_EXHAUSTED = "participant_live_capacity_exhausted"
+    PARTICIPANT_MEMORY_CAPACITY_EXHAUSTED = "participant_memory_capacity_exhausted"
+    EXTERNAL_IO_DEFERRED = "external_io_deferred"
+    OPENCODE_ENDPOINT_UNREACHABLE = "opencode_endpoint_unreachable"
+    OPENCODE_ENDPOINT_REFUSED = "opencode_endpoint_refused"
+    OPENCODE_ENDPOINT_LOST = "opencode_endpoint_lost"
+    OPENCODE_ENDPOINT_HEALTH_TIMEOUT = "opencode_endpoint_health_timeout"
+    OPENCODE_CONTAINER_OOM = "opencode_container_oom"
+    OPENCODE_EVENT_STREAM_ROUTE_UNREACHABLE = "opencode_event_stream_route_unreachable"
+    OPENCODE_EVENT_STREAM_ENDPOINT_REFUSED = "opencode_event_stream_endpoint_refused"
+    OPENCODE_EVENT_STREAM_READ_TIMEOUT = "opencode_event_stream_read_timeout"
+    OPENCODE_EVENT_STREAM_URL_ERROR = "opencode_event_stream_url_error"
+    OPENCODE_EVENT_STREAM_RECONNECT_GRACE_EXHAUSTED = (
+        "opencode_event_stream_reconnect_grace_exhausted"
+    )
+    PARTICIPANT_SESSION_MISSING = "participant_session_missing"
+    PARTICIPANT_SESSION_START_FAILED = "participant_session_start_failed"
+    PARTICIPANT_LIVE_UNBOUND = "participant_live_unbound"
+    PARTICIPANT_LIVE_HANDLE_MISSING = "participant_live_handle_missing"
+    PARTICIPANT_BINDING_FAILED = "participant_binding_failed"
+    CLAIMED_TASK_WITHOUT_PARTICIPANT = "claimed_task_without_participant"
+    STALE_CLAIM_REAPED = "stale_claim_reaped"
+    RUNTIME_INTENT_BACKLOG = "runtime_intent_backlog"
+    UNKNOWN_UNHEALTHY_EXPIRED = "unknown_unhealthy_expired"
+    RUNTIME_NO_PRODUCTIVE_PROGRESS = "runtime_no_productive_progress"
+
+
+class ManagedResearchFailureFamily(StrEnum):
+    UNKNOWN = "unknown"
+    VALIDATION = "validation"
+    BOOTSTRAP = "bootstrap"
+    DISPATCH = "dispatch"
+    RUNTIME = "runtime"
+    RUNTIME_RECOVERY = "runtime_recovery"
+    TERMINALIZATION = "terminalization"
+    CLEANUP = "cleanup"
+    INFRASTRUCTURE = "infrastructure"
+    USAGE_CAPTURE = "usage_capture"
+    PARTICIPANT_START = "participant_start"
+    ORCHESTRATOR_CYCLE = "orchestrator_cycle"
+    ORCHESTRATOR_PROVIDER = "orchestrator_provider"
+    ORCHESTRATOR_CODEX = "orchestrator_codex"
+
+
+class ManagedResearchFailureSeverity(StrEnum):
+    WARNING = "warning"
+    ERROR = "error"
+    FATAL = "fatal"
+
+
+class ManagedResearchFailureScope(StrEnum):
+    ACTOR = "actor"
+    TASK = "task"
+    RUN = "run"
+
+
+@dataclass(frozen=True)
+class ManagedResearchFailureClassification:
+    family: ManagedResearchFailureFamily
+    code: str
+    severity: ManagedResearchFailureSeverity
+    retryable: bool
+    scope: ManagedResearchFailureScope | None = None
+    operator_action: str | None = None
+    detail: str | None = None
+    actor_id: str | None = None
+    actor_key: str | None = None
+    task_id: str | None = None
+    task_key: str | None = None
+    recorded_at: str | None = None
+    family_raw: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+    @classmethod
+    def from_wire(cls, payload: object) -> ManagedResearchFailureClassification:
+        if not isinstance(payload, dict):
+            raise ValueError("run failure classification must be an object")
+        family = payload.get("family")
+        code = payload.get("code")
+        severity = payload.get("severity")
+        retryable = payload.get("retryable")
+        if not isinstance(family, str) or not isinstance(code, str):
+            raise ValueError("run failure classification requires family and code")
+        if not isinstance(severity, str) or not isinstance(retryable, bool):
+            raise ValueError("run failure classification requires severity and retryable")
+        try:
+            parsed_family = ManagedResearchFailureFamily(family)
+        except ValueError:
+            parsed_family = ManagedResearchFailureFamily.UNKNOWN
+        return cls(
+            family=parsed_family,
+            code=code,
+            severity=ManagedResearchFailureSeverity(severity),
+            retryable=retryable,
+            scope=(
+                ManagedResearchFailureScope(payload["scope"])
+                if isinstance(payload.get("scope"), str)
+                else None
+            ),
+            operator_action=payload.get("operator_action")
+            if isinstance(payload.get("operator_action"), str)
+            else None,
+            detail=payload.get("detail") if isinstance(payload.get("detail"), str) else None,
+            actor_id=payload.get("actor_id") if isinstance(payload.get("actor_id"), str) else None,
+            actor_key=payload.get("actor_key")
+            if isinstance(payload.get("actor_key"), str)
+            else None,
+            task_id=payload.get("task_id") if isinstance(payload.get("task_id"), str) else None,
+            task_key=payload.get("task_key") if isinstance(payload.get("task_key"), str) else None,
+            recorded_at=payload.get("recorded_at")
+            if isinstance(payload.get("recorded_at"), str)
+            else None,
+            family_raw=family if parsed_family is ManagedResearchFailureFamily.UNKNOWN else None,
+            raw={str(key): value for key, value in payload.items()},
+        )
+
+    def to_wire(self) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in {
+                **self.raw,
+                "family": self.family.value,
+                "code": self.code,
+                "severity": self.severity.value,
+                "retryable": self.retryable,
+                "scope": self.scope.value if self.scope is not None else None,
+                "operator_action": self.operator_action,
+                "detail": self.detail,
+                "actor_id": self.actor_id,
+                "actor_key": self.actor_key,
+                "task_id": self.task_id,
+                "task_key": self.task_key,
+                "recorded_at": self.recorded_at,
+                "family_raw": self.family_raw,
+            }.items()
+            if value is not None
+        }
+
+
+__all__ = [
+    "ActorFailureReason",
+    "ManagedResearchFailureClassification",
+    "ManagedResearchFailureFamily",
+    "ManagedResearchFailureScope",
+    "ManagedResearchFailureSeverity",
+]

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/contracts/image_releases.py

@@ -697,11 +697,13 @@ class ActorRuntimeImageMaterialization:
         object.__setattr__(
             self, "daytona_pullable", required_bool({"value": self.daytona_pullable}, "value")
         )
-        expected = (
-            ("org_registry", "wasabi_artifact") if self.daytona_pullable else ("wasabi_artifact",)
+        allowed = (
+            (("org_registry",), ("org_registry", "wasabi_artifact"))
+            if self.daytona_pullable
+            else (("wasabi_artifact",),)
         )
-        if self.image_substrates != expected:
-            raise ValueError("image_substrates must exactly describe the admitted execution path")
+        if self.image_substrates not in allowed:
+            raise ValueError("image_substrates must exactly describe the admitted execution paths")
 
     @classmethod
     def from_wire(cls, value: JsonValue) -> ActorRuntimeImageMaterialization:
@@ -1169,6 +1171,63 @@ class ImageReleaseFinalize:
         }
 
 
+@dataclass(frozen=True, slots=True)
+class RegistryActorRuntimeImageRegistrationRequest:
+    declaration: ActorRuntimeImageReleaseDeclaration
+    image_config_digest: str
+    package_release_timestamps: TimestampMap = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.declaration, ActorRuntimeImageReleaseDeclaration):
+            raise ValueError("declaration must be ActorRuntimeImageReleaseDeclaration")
+        object.__setattr__(
+            self,
+            "image_config_digest",
+            digest(self.image_config_digest, field="image_config_digest"),
+        )
+        object.__setattr__(
+            self,
+            "package_release_timestamps",
+            _timestamp_map(self.package_release_timestamps),
+        )
+        _check_packages(self.declaration, self.package_release_timestamps)
+
+    def to_wire(self) -> JsonObject:
+        return {
+            "declaration": self.declaration.to_wire(),
+            "image_config_digest": self.image_config_digest,
+            "package_release_timestamps": _timestamp_wire(self.package_release_timestamps),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class RegistryActorRuntimeImageRegistration:
+    schema_version: str
+    runtime_image_release: ActorRuntimeImageMaterialization
+
+    @classmethod
+    def from_wire(cls, value: JsonValue) -> RegistryActorRuntimeImageRegistration:
+        payload = _obj(
+            value,
+            "registry actor runtime image registration",
+            frozenset({"schema_version", "runtime_image_release"}),
+        )
+        return cls(
+            _const(
+                payload["schema_version"],
+                "schema_version",
+                "smr-actor-image-registry-registration-v1",
+            ),
+            ActorRuntimeImageMaterialization.from_wire(payload["runtime_image_release"]),
+        )
+
+    def to_wire(self) -> JsonObject:
+        return {
+            "schema_version": self.schema_version,
+            "runtime_image_release": self.runtime_image_release.to_wire(),
+        }
+
+
 @dataclass(frozen=True, slots=True)
 class ActorRuntimeImageReleaseList:
     schema_version: str
@@ -1229,6 +1288,8 @@ __all__ = [
     "ActorRuntimeImageReleaseArchive",
     "ActorRuntimeImageReleaseDeclaration",
     "ActorRuntimeImageReleaseList",
+    "RegistryActorRuntimeImageRegistration",
+    "RegistryActorRuntimeImageRegistrationRequest",
     "ActorImageCapability",
     "CraftaxScorerImageRelease",
     "CraftaxScorerImageReleaseDeclaration",

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/contracts/run_observability.py

@@ -6,6 +6,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field
 from enum import StrEnum
 
+from synth_ai.sdk.research.contracts.failure import ManagedResearchFailureClassification
 from synth_ai.sdk.research.contracts.run_state import (
     ManagedResearchRun,
     ManagedResearchRunLivenessPhase,
@@ -1307,7 +1308,7 @@ class ManagedResearchRunContractIncidents:
 class ManagedResearchRunContractDiagnostics:
     lifecycle_invariants: list[dict[str, object]] = field(default_factory=list)
     resource_wait: dict[str, object] | None = None
-    failure_classification: dict[str, object] | None = None
+    failure_classification: ManagedResearchFailureClassification | None = None
 
     @classmethod
     def from_wire(cls, payload: object) -> ManagedResearchRunContractDiagnostics:
@@ -1327,10 +1328,12 @@ class ManagedResearchRunContractDiagnostics:
             )
             if resource_wait is not None
             else None,
-            failure_classification=dict(
-                _require_mapping(
-                    failure_classification,
-                    label="run_contract.diagnostics.failure_classification",
+            failure_classification=ManagedResearchFailureClassification.from_wire(
+                dict(
+                    _require_mapping(
+                        failure_classification,
+                        label="run_contract.diagnostics.failure_classification",
+                    )
                 )
             )
             if failure_classification is not None
@@ -1509,6 +1512,7 @@ __all__ = [
     "ManagedResearchRunContractArtifacts",
     "ManagedResearchRunContractContainerEvalPackages",
     "ManagedResearchRunContractDiagnostics",
+    "ManagedResearchFailureClassification",
     "ManagedResearchRunContractExecutionRoute",
     "ManagedResearchRunContractFinalization",
     "ManagedResearchRunContractIncidents",

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/image_releases.py

@@ -24,6 +24,8 @@ from synth_ai.sdk.research.contracts.image_releases import (
     ImageReleaseId,
     ImageReleaseUpload,
     ImageReleaseUploadRequest,
+    RegistryActorRuntimeImageRegistration,
+    RegistryActorRuntimeImageRegistrationRequest,
     RuntimeImageReleaseId,
     image_release_from_wire,
 )
@@ -165,6 +167,29 @@ class ImageReleasesAPI:
         )
         return _finalize(value, request=request)
 
+    def register_registry_image(
+        self,
+        request: RegistryActorRuntimeImageRegistrationRequest,
+    ) -> RegistryActorRuntimeImageRegistration:
+        """Register an org-scoped digest already published to the Synth registry."""
+
+        if not isinstance(request, RegistryActorRuntimeImageRegistrationRequest):
+            raise ValueError("request must be RegistryActorRuntimeImageRegistrationRequest")
+        value = self._transport.execute(
+            _request(
+                "register_customer_actor_registry_image",
+                "/smr/v1/image-releases/register-registry",
+                body=request.to_wire(),
+            )
+        )
+        result = RegistryActorRuntimeImageRegistration.from_wire(cast(JsonValue, value))
+        if (
+            result.runtime_image_release.resolved_digest
+            != request.declaration.image_manifest_digest
+        ):
+            raise ValueError("registry image response changed its manifest digest")
+        return result
+
     def upload_archive(
         self,
         archive_path: str | Path,
@@ -284,6 +309,29 @@ class AsyncImageReleasesAPI:
         )
         return _finalize(value, request=request)
 
+    async def register_registry_image(
+        self,
+        request: RegistryActorRuntimeImageRegistrationRequest,
+    ) -> RegistryActorRuntimeImageRegistration:
+        """Register an org-scoped digest already published to the Synth registry."""
+
+        if not isinstance(request, RegistryActorRuntimeImageRegistrationRequest):
+            raise ValueError("request must be RegistryActorRuntimeImageRegistrationRequest")
+        value = await self._transport.execute(
+            _request(
+                "register_customer_actor_registry_image",
+                "/smr/v1/image-releases/register-registry",
+                body=request.to_wire(),
+            )
+        )
+        result = RegistryActorRuntimeImageRegistration.from_wire(cast(JsonValue, value))
+        if (
+            result.runtime_image_release.resolved_digest
+            != request.declaration.image_manifest_digest
+        ):
+            raise ValueError("registry image response changed its manifest digest")
+        return result
+
     async def upload_archive(
         self,
         archive_path: str | Path,

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/operations.py

@@ -50,6 +50,13 @@ RESEARCH_OPERATIONS = {
             "/smr/v1/image-releases/upload-url",
             mutation=True,
         ),
+        _operation(
+            "register_customer_actor_registry_image",
+            HttpMethod.POST,
+            "/smr/v1/image-releases/register-registry",
+            mutation=True,
+            idempotent=True,
+        ),
         _operation("create_factory", HttpMethod.POST, "/smr/factories", mutation=True),
         _operation(
             "provision_research_intern",

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/public.py

@@ -43,6 +43,7 @@ from synth_ai.sdk.research.contracts import (
     ActivityWindow,
     ActivityWindowReceipt,
     ActivityWorkProduct,
+    ActorFailureReason,
     ActorHarness,
     ActorId,
     ActorImageBinding,
@@ -153,6 +154,10 @@ from synth_ai.sdk.research.contracts import (
     MagiDecisionReceiptResponse,
     MagiDecisionRequest,
     MagiMode,
+    ManagedResearchFailureClassification,
+    ManagedResearchFailureFamily,
+    ManagedResearchFailureScope,
+    ManagedResearchFailureSeverity,
     MessageId,
     OpenEndedQuestionSpec,
     ParticipantSessionId,
@@ -197,6 +202,8 @@ from synth_ai.sdk.research.contracts import (
     ProjectWorkspaceInputs,
     ProviderBinding,
     ProviderPolicy,
+    RegistryActorRuntimeImageRegistration,
+    RegistryActorRuntimeImageRegistrationRequest,
     ResearchInternFactoryMembershipResponse,
     ResearchInternPatchRequest,
     ResearchInternPolicySet,
@@ -394,6 +401,7 @@ __all__ = [
     "ActivityWindow",
     "ActivityWindowReceipt",
     "ActivityWorkProduct",
+    "ActorFailureReason",
     "ActiveActorModel",
     "ActorId",
     "ActorRuntimeImageMaterialization",
@@ -401,12 +409,18 @@ __all__ = [
     "ActorRuntimeImageReleaseArchive",
     "ActorRuntimeImageReleaseDeclaration",
     "ActorRuntimeImageReleaseList",
+    "RegistryActorRuntimeImageRegistration",
+    "RegistryActorRuntimeImageRegistrationRequest",
     "ArtifactId",
     "ActorHarness",
     "ActorModel",
     "ActorTokenUsage",
     "ActorUsage",
     "ActorUsageMoney",
+    "ManagedResearchFailureClassification",
+    "ManagedResearchFailureFamily",
+    "ManagedResearchFailureScope",
+    "ManagedResearchFailureSeverity",
     "AsyncClient",
     "AsyncVisualsAPI",
     "Branch",

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai/sdk/research/session/runs.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import time
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, List, cast
+from typing import Any, List
 
 import httpx
 
@@ -313,20 +313,15 @@ class RunHandle:
             if contract.terminal:
                 if raise_if_failed and contract.public_state.value in {"failed", "blocked"}:
                     failure = contract.diagnostics.failure_classification
-                    if (
-                        isinstance(failure, Mapping)
-                        and str(failure.get("code") or "").strip()
-                        == "inference_provider_unavailable"
-                    ):
-                        detail = dict(failure)
-                        message = str(detail.get("detail") or "").strip() or (
+                    if failure is not None and failure.code == "inference_provider_unavailable":
+                        message = str(failure.detail or "").strip() or (
                             f"run {self.run_id} ended because its inference provider "
                             "was temporarily unavailable"
                         )
                         raise ResearchInferenceProviderUnavailableError(
                             message,
                             status_code=None,
-                            detail=detail,
+                            detail=failure.to_wire(),
                         )
                     msg = self.explain_blocker() or (
                         f"run {self.run_id} ended in state {contract.public_state.value}"
@@ -1771,10 +1766,10 @@ class RunsAPI(_ClientNamespace):
             return detail or code or "run lifecycle invariant failed"
         failure = contract.diagnostics.failure_classification
         if failure is not None:
-            code = str(failure.get("code") or "").strip()
-            detail = str(failure.get("detail") or "").strip()
-            route = failure.get("route")
-            route_mapping = cast(Mapping[str, Any], route) if isinstance(route, Mapping) else {}
+            code = failure.code.strip()
+            detail = str(failure.detail or "").strip()
+            route = failure.to_wire().get("route")
+            route_mapping = route if isinstance(route, Mapping) else {}
             model = str(route_mapping.get("model") or "").strip()
             suffix = f" model={model}" if model else ""
             if detail:

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596/synth_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.18.1.dev594
+Version: 0.18.1.dev596
 Summary: Python SDK and CLI for Synth Managed Research and Research Factory
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT

{synth_ai-0.18.1.dev594 → synth_ai-0.18.1.dev596}/synth_ai.egg-info/SOURCES.txt

@@ -143,6 +143,7 @@ synth_ai/sdk/research/contracts/factory_evidence.py
 synth_ai/sdk/research/contracts/factory_lenses.py
 synth_ai/sdk/research/contracts/factory_operations.py
 synth_ai/sdk/research/contracts/factory_role_receipts.py
+synth_ai/sdk/research/contracts/failure.py
 synth_ai/sdk/research/contracts/image_releases.py
 synth_ai/sdk/research/contracts/local_execution_profile.py
 synth_ai/sdk/research/contracts/operator_evidence.py