agentinputlab 0.1.0a1__py3-none-any.whl

agentinputlab/experiments/controls.py

@@ -0,0 +1,340 @@
+"""Mechanism controls that preserve visible input while retaining intervention cost."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from agentinputlab.contracts.enums import PatchOp, SemanticFamily, TracePhase
+from agentinputlab.contracts.errors import ValidationError
+from agentinputlab.contracts.lifecycle import Intervention, InterventionContext
+from agentinputlab.contracts.patch import InputPatch, PatchOperation
+from agentinputlab.contracts.serialization import content_hash, freeze_mapping
+from agentinputlab.contracts.state import FrozenAgentState
+from agentinputlab.contracts.trace import ExecutionTrace, TraceEvent
+
+if TYPE_CHECKING:
+    from agentinputlab.experiments.drivers.static_production import StaticArmBuildRequest
+
+COST_MATCHED_NO_OP_RELEASE_ID = "baseline.no_op_cost_shadow"
+COST_MATCHED_NO_OP_BUILDER_PROTOCOL = "agentinputlab.cost-matched-no-op-builder.v1"
+COST_MATCHED_EXTERNAL_PAYLOAD_PROTOCOL = "agentinputlab.cost-matched-external-payload-builder.v1"
+
+
+@dataclass(slots=True)
+class CostMatchedNoOpIntervention:
+    """Run a frozen intervention, discard its patch, and preserve its measured cost."""
+
+    delegate: Intervention
+    method_id: str = "no_op_cost_shadow"
+    release_id: str = COST_MATCHED_NO_OP_RELEASE_ID
+    family: SemanticFamily = SemanticFamily.NO_OP
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.delegate, Intervention):
+            raise TypeError("cost-matched NO_OP requires an Intervention delegate")
+        if self.delegate.family is SemanticFamily.NO_OP:
+            raise ValidationError("cost-matched NO_OP delegate must perform a real intervention")
+        if self.release_id != COST_MATCHED_NO_OP_RELEASE_ID:
+            raise ValidationError("cost-matched NO_OP release identity is fixed")
+
+    def propose(self, state: FrozenAgentState, context: InterventionContext) -> InputPatch:
+        candidate = self.delegate.propose(state, context)
+        if not isinstance(candidate, InputPatch):
+            raise ValidationError("cost-matched NO_OP delegate returned an invalid patch")
+        if candidate.source_state_hash != state.state_hash:
+            raise ValidationError("cost-matched NO_OP delegate patch belongs to another state")
+        trace = ExecutionTrace(
+            method_id=self.method_id,
+            release_id=self.release_id,
+            events=(
+                TraceEvent(
+                    phase=TracePhase.FINALIZE,
+                    name="discard_intervention_patch",
+                    payload={
+                        "delegate_method_id": self.delegate.method_id,
+                        "delegate_release_id": self.delegate.release_id,
+                        "discarded_patch_hash": candidate.patch_hash,
+                        "visible_input_unchanged": True,
+                    },
+                ),
+            ),
+            counters=dict(candidate.trace.counters),
+            warnings=("delegate patch intentionally discarded for cost-only mechanism control",),
+        )
+        return InputPatch(
+            method_id=self.method_id,
+            release_id=self.release_id,
+            source_state_hash=state.state_hash,
+            operations=(
+                PatchOperation(
+                    PatchOp.NO_OP,
+                    rationale="cost-matched shadow preserves the original visible input",
+                ),
+            ),
+            trace=trace,
+            implementation_identity="cost_shadow:"
+            + content_hash(
+                {
+                    "delegate_method_id": self.delegate.method_id,
+                    "delegate_release_id": self.delegate.release_id,
+                }
+            ),
+            profile_kind="controlled_adapter",
+            metadata={
+                "control_kind": "optimizer_orchestration_only",
+                "delegate_method_id": self.delegate.method_id,
+                "delegate_release_id": self.delegate.release_id,
+                "discarded_patch_hash": candidate.patch_hash,
+                "visible_input_unchanged": True,
+            },
+        )
+
+
+class CostMatchedNoOpBuilder:
+    """Static-driver builder for an exact registry-backed shadow delegate."""
+
+    builder_kind = "intervention"
+
+    def fingerprint(self) -> Mapping[str, Any]:
+        return freeze_mapping(
+            {
+                "builder_id": COST_MATCHED_NO_OP_BUILDER_PROTOCOL,
+                "schema_version": 1,
+                "delegate_builder": "agentinputlab.registry-intervention-builder.v1",
+                "output_release_id": COST_MATCHED_NO_OP_RELEASE_ID,
+                "visible_input_policy": "discard_delegate_patch",
+            }
+        )
+
+    def preflight(self, parameters: Mapping[str, Any]) -> Sequence[str]:
+        from agentinputlab.experiments.builders.registry_intervention import (
+            RegistryInterventionBuilder,
+        )
+
+        try:
+            parsed = _parameters(parameters)
+        except ValidationError as exc:
+            return (str(exc),)
+        return RegistryInterventionBuilder().preflight(_delegate_parameters(parsed))
+
+    def build(self, request: StaticArmBuildRequest) -> CostMatchedNoOpIntervention:
+        from agentinputlab.experiments.builders.registry_intervention import (
+            RegistryInterventionBuilder,
+        )
+        from agentinputlab.experiments.drivers.static_production import (
+            StaticArmBuildRequest,
+        )
+
+        if not isinstance(request, StaticArmBuildRequest):
+            raise TypeError("cost-matched NO_OP builder requires StaticArmBuildRequest")
+        if (
+            request.release_id != COST_MATCHED_NO_OP_RELEASE_ID
+            or request.family is not SemanticFamily.NO_OP
+        ):
+            raise ValidationError("cost-matched NO_OP builder received another arm identity")
+        parsed = _parameters(request.builder_parameters)
+        delegate_request = StaticArmBuildRequest(
+            arm_id=request.arm_id + ".delegate",
+            release_id=parsed["delegate_release_id"],
+            family=SemanticFamily(parsed["delegate_family"]),
+            profile_kind=request.profile_kind,
+            model_slot=request.model_slot,
+            seed=request.seed,
+            builder_parameters=_delegate_parameters(parsed),
+            arm_parameters=request.arm_parameters,
+            runtime=request.runtime,
+        )
+        delegate = RegistryInterventionBuilder().build(delegate_request)
+        return CostMatchedNoOpIntervention(delegate=delegate)
+
+
+def cost_matched_no_op_builder_factory() -> CostMatchedNoOpBuilder:
+    return CostMatchedNoOpBuilder()
+
+
+class CostMatchedExternalPayloadBuilder:
+    """Build an atomic-arena instruction that discards a delegate's patch."""
+
+    builder_kind = "arm_payload"
+
+    def fingerprint(self) -> Mapping[str, Any]:
+        return freeze_mapping(
+            {
+                "builder_id": COST_MATCHED_EXTERNAL_PAYLOAD_PROTOCOL,
+                "schema_version": 1,
+                "output_release_id": COST_MATCHED_NO_OP_RELEASE_ID,
+                "required_runtime_action": "execute_optimizer_discard_patch",
+                "visible_input_policy": "preserve_original_state",
+            }
+        )
+
+    def preflight(self, parameters: Mapping[str, Any]) -> Sequence[str]:
+        try:
+            parsed = _external_parameters(parameters)
+        except ValidationError as exc:
+            return (str(exc),)
+        if not parsed["runtime_support_attested"]:
+            return ("external runtime has not attested execute_optimizer_discard_patch support",)
+        return ()
+
+    def build(self, request: Any) -> Any:
+        from agentinputlab.experiments.drivers.external_arena import (
+            ExternalArmPayload,
+            ExternalArmPayloadBuildRequest,
+        )
+
+        if not isinstance(request, ExternalArmPayloadBuildRequest):
+            raise TypeError(
+                "cost-matched external payload builder requires ExternalArmPayloadBuildRequest"
+            )
+        if request.release_id != COST_MATCHED_NO_OP_RELEASE_ID or request.family not in {
+            SemanticFamily.REFORMULATE,
+            SemanticFamily.DECOMPOSE,
+            SemanticFamily.ACQUIRE,
+            SemanticFamily.CLARIFY,
+            SemanticFamily.CURATE,
+        }:
+            raise ValidationError(
+                "cost-matched external payload builder received another arm identity"
+            )
+        parsed = _external_parameters(request.builder_parameters)
+        if not parsed["runtime_support_attested"]:
+            raise ValidationError(
+                "cost-matched external payload requires runtime support attestation"
+            )
+        shadow_family = request.arm_parameters.get("shadow_family")
+        shadow_release = request.arm_parameters.get("shadow_release_id")
+        if (
+            shadow_family != parsed["delegate_family"]
+            or shadow_release != parsed["delegate_release_id"]
+            or request.family.value != parsed["delegate_family"]
+        ):
+            raise ValidationError(
+                "cost-matched external arm parameters differ from its locked delegate"
+            )
+        payload = {
+            "schema_version": 1,
+            "protocol": COST_MATCHED_EXTERNAL_PAYLOAD_PROTOCOL,
+            "action": "execute_optimizer_discard_patch",
+            "delegate": {
+                "family": parsed["delegate_family"],
+                "release_id": parsed["delegate_release_id"],
+                "configuration_sha256": parsed["delegate_configuration_sha256"],
+            },
+            "checkpoint_identity_sha256": request.checkpoint.identity_hash,
+            "visible_state_sha256": request.checkpoint.visible_state.state_hash,
+            "model_slot": request.model_slot,
+            "seed": request.seed,
+            "visible_input_unchanged": True,
+            "discard_delegate_patch": True,
+        }
+        return ExternalArmPayload(
+            arm_id=request.arm_id,
+            release_id=request.release_id,
+            family=request.family,
+            profile_kind=request.profile_kind,
+            payload=payload,
+        )
+
+
+def cost_matched_external_payload_builder_factory() -> CostMatchedExternalPayloadBuilder:
+    return CostMatchedExternalPayloadBuilder()
+
+
+def _parameters(value: Mapping[str, Any]) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ValidationError("cost-matched NO_OP parameters must be an object")
+    required = {
+        "schema_version",
+        "delegate_release_id",
+        "delegate_family",
+        "constructor_kwargs",
+        "arm_parameter_bindings",
+        "required_environment",
+    }
+    if set(value) != required or value.get("schema_version") != 1:
+        raise ValidationError("cost-matched NO_OP parameter schema is invalid")
+    release_id = value.get("delegate_release_id")
+    family = value.get("delegate_family")
+    if not isinstance(release_id, str) or not release_id.strip():
+        raise ValidationError("cost-matched NO_OP delegate_release_id must be non-empty")
+    try:
+        SemanticFamily(family)
+    except (TypeError, ValueError) as exc:
+        raise ValidationError("cost-matched NO_OP delegate_family is invalid") from exc
+    if SemanticFamily(family) in {SemanticFamily.NO_OP, SemanticFamily.COMPOSITE}:
+        raise ValidationError("cost-matched NO_OP delegate must be one prompt family")
+    if not isinstance(value["constructor_kwargs"], Mapping):
+        raise ValidationError("cost-matched NO_OP constructor_kwargs must be an object")
+    if not isinstance(value["arm_parameter_bindings"], Mapping):
+        raise ValidationError("cost-matched NO_OP arm_parameter_bindings must be an object")
+    required_environment = value["required_environment"]
+    if isinstance(required_environment, (str, bytes)) or not isinstance(
+        required_environment, Sequence
+    ):
+        raise ValidationError("cost-matched NO_OP required_environment must be an array")
+    try:
+        return freeze_mapping(value)
+    except (TypeError, ValueError) as exc:
+        raise ValidationError("cost-matched NO_OP parameters must be canonical JSON") from exc
+
+
+def _delegate_parameters(value: Mapping[str, Any]) -> Mapping[str, Any]:
+    return freeze_mapping(
+        {
+            "schema_version": 1,
+            "release_id": value["delegate_release_id"],
+            "constructor_kwargs": value["constructor_kwargs"],
+            "runtime_bindings": {},
+            "arm_parameter_bindings": value["arm_parameter_bindings"],
+            "required_environment": value["required_environment"],
+        }
+    )
+
+
+def _external_parameters(value: Mapping[str, Any]) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ValidationError("cost-matched external parameters must be an object")
+    required = {
+        "schema_version",
+        "delegate_release_id",
+        "delegate_family",
+        "delegate_configuration_sha256",
+        "runtime_support_attested",
+    }
+    if set(value) != required or value.get("schema_version") != 1:
+        raise ValidationError("cost-matched external parameter schema is invalid")
+    release_id = value.get("delegate_release_id")
+    family = value.get("delegate_family")
+    digest = value.get("delegate_configuration_sha256")
+    if not isinstance(release_id, str) or not release_id.strip():
+        raise ValidationError("cost-matched external delegate_release_id must be non-empty")
+    try:
+        typed_family = SemanticFamily(family)
+    except (TypeError, ValueError) as exc:
+        raise ValidationError("cost-matched external delegate_family is invalid") from exc
+    if typed_family in {SemanticFamily.NO_OP, SemanticFamily.COMPOSITE}:
+        raise ValidationError("cost-matched external delegate must be one prompt family")
+    if (
+        not isinstance(digest, str)
+        or len(digest) != 64
+        or any(character not in "0123456789abcdef" for character in digest)
+    ):
+        raise ValidationError("cost-matched external delegate_configuration_sha256 must be SHA-256")
+    if not isinstance(value["runtime_support_attested"], bool):
+        raise ValidationError("cost-matched external runtime_support_attested must be boolean")
+    return freeze_mapping(value)
+
+
+__all__ = [
+    "COST_MATCHED_EXTERNAL_PAYLOAD_PROTOCOL",
+    "COST_MATCHED_NO_OP_BUILDER_PROTOCOL",
+    "COST_MATCHED_NO_OP_RELEASE_ID",
+    "CostMatchedExternalPayloadBuilder",
+    "CostMatchedNoOpBuilder",
+    "CostMatchedNoOpIntervention",
+    "cost_matched_external_payload_builder_factory",
+    "cost_matched_no_op_builder_factory",
+]

agentinputlab/experiments/driver_guard.py

@@ -0,0 +1,205 @@
+"""Runtime wrapper that keeps preflight identities attached through persistence."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any
+
+from agentinputlab.contracts.errors import ArtifactError
+from agentinputlab.contracts.serialization import freeze_mapping
+
+from .bindings import (
+    FrozenBindingReceipt,
+    build_guarded_driver_fingerprint,
+    resolve_frozen_binding_receipt,
+)
+from .executor import ExperimentCellResult, ExperimentDriver
+from .parity_identity import (
+    HOST_EXECUTION_RECEIPT_PROTOCOL,
+    ParityImplementationContract,
+    validate_host_process_cell_result,
+    validate_parity_cell_result,
+)
+from .plan import ExperimentCell
+from .schema import ExperimentManifest
+
+_GUARDED_ENTRYPOINT = "agentinputlab.experiments.driver_guard:active_guarded_driver_factory"
+
+
+@dataclass(frozen=True, slots=True)
+class _GuardConfiguration:
+    manifest: ExperimentManifest
+    operator_entrypoint: str
+    operator_fingerprint: Mapping[str, Any]
+    binding_receipt: FrozenBindingReceipt
+    parity_contract: ParityImplementationContract | None
+
+    def __post_init__(self) -> None:
+        if self.operator_entrypoint == _GUARDED_ENTRYPOINT:
+            raise ArtifactError("guarded driver cannot recursively wrap itself")
+        try:
+            fingerprint = freeze_mapping(self.operator_fingerprint)
+        except (TypeError, ValueError) as exc:
+            raise ArtifactError("operator driver fingerprint is not canonical JSON") from exc
+        if not fingerprint:
+            raise ArtifactError("operator driver fingerprint must not be empty")
+        object.__setattr__(self, "operator_fingerprint", fingerprint)
+
+
+_ACTIVE_GUARD: ContextVar[_GuardConfiguration | None] = ContextVar(
+    "agentinputlab_active_experiment_driver_guard",
+    default=None,
+)
+
+
+class GuardedExperimentDriver:
+    """Bind one operator driver to the exact receipt accepted by preflight."""
+
+    def __init__(
+        self,
+        operator: ExperimentDriver,
+        *,
+        manifest: ExperimentManifest,
+        expected_operator_fingerprint: Mapping[str, Any],
+        binding_receipt: FrozenBindingReceipt,
+        parity_contract: ParityImplementationContract | None = None,
+    ) -> None:
+        if not isinstance(operator, ExperimentDriver):
+            raise ArtifactError("guard requires an ExperimentDriver implementation")
+        self._operator = operator
+        self._manifest = manifest
+        self._expected_operator_fingerprint = freeze_mapping(expected_operator_fingerprint)
+        self._binding_receipt = binding_receipt
+        self._parity_contract = parity_contract
+        self._require_stable_operator_fingerprint()
+        self._fingerprint = build_guarded_driver_fingerprint(
+            self._expected_operator_fingerprint,
+            binding_receipt,
+            parity_contract=(parity_contract.to_dict() if parity_contract is not None else None),
+        )
+
+    def fingerprint(self) -> Mapping[str, Any]:
+        self._require_stable_operator_fingerprint()
+        return self._fingerprint
+
+    def preflight(self, manifest: ExperimentManifest) -> Sequence[str]:
+        self._require_manifest(manifest)
+        self._require_stable_bindings()
+        self._require_stable_operator_fingerprint()
+        blockers = self._operator.preflight(manifest)
+        self._require_stable_operator_fingerprint()
+        self._require_stable_bindings()
+        return blockers
+
+    def execute_cell(
+        self,
+        manifest: ExperimentManifest,
+        cell: ExperimentCell,
+    ) -> ExperimentCellResult:
+        self._require_manifest(manifest)
+        self._require_stable_bindings()
+        self._require_stable_operator_fingerprint()
+        result = self._operator.execute_cell(manifest, cell)
+        self._require_stable_operator_fingerprint()
+        self._require_stable_bindings()
+        if self._parity_contract is not None and isinstance(result, ExperimentCellResult):
+            validate_parity_cell_result(
+                cell,
+                result,
+                binding_receipt=self._binding_receipt,
+                contract=self._parity_contract,
+                operator_fingerprint=self._expected_operator_fingerprint,
+            )
+        elif (
+            isinstance(result, ExperimentCellResult)
+            and self._expected_operator_fingerprint.get("execution_receipt_protocol")
+            == HOST_EXECUTION_RECEIPT_PROTOCOL
+        ):
+            validate_host_process_cell_result(
+                cell,
+                result,
+                binding_receipt=self._binding_receipt,
+                operator_fingerprint=self._expected_operator_fingerprint,
+            )
+        return result
+
+    def _require_manifest(self, manifest: ExperimentManifest) -> None:
+        if manifest.manifest_hash != self._manifest.manifest_hash:
+            raise ArtifactError("guarded driver received another experiment manifest")
+
+    def _require_stable_operator_fingerprint(self) -> None:
+        try:
+            observed = freeze_mapping(self._operator.fingerprint())
+        except (TypeError, ValueError) as exc:
+            raise ArtifactError("operator driver fingerprint is not canonical JSON") from exc
+        if observed != self._expected_operator_fingerprint:
+            raise ArtifactError("operator driver fingerprint changed after frozen preflight")
+
+    def _require_stable_bindings(self) -> None:
+        """Re-attest every prerequisite immediately around each cell."""
+
+        current = resolve_frozen_binding_receipt(self._manifest)
+        if current.to_dict() != self._binding_receipt.to_dict():
+            raise ArtifactError("experiment prerequisite bindings changed after frozen preflight")
+
+
+@contextmanager
+def activate_guarded_driver(
+    *,
+    manifest: ExperimentManifest,
+    operator_entrypoint: str,
+    operator_fingerprint: Mapping[str, Any],
+    binding_receipt: FrozenBindingReceipt,
+    parity_contract: ParityImplementationContract | None = None,
+) -> Iterator[str]:
+    """Install a process-local factory used only around one synchronous run."""
+
+    configuration = _GuardConfiguration(
+        manifest=manifest,
+        operator_entrypoint=operator_entrypoint,
+        operator_fingerprint=operator_fingerprint,
+        binding_receipt=binding_receipt,
+        parity_contract=parity_contract,
+    )
+    token = _ACTIVE_GUARD.set(configuration)
+    try:
+        yield _GUARDED_ENTRYPOINT
+    finally:
+        _ACTIVE_GUARD.reset(token)
+
+
+def active_guarded_driver_factory() -> GuardedExperimentDriver:
+    """Zero-argument factory consumed by the existing executor entrypoint API."""
+
+    configuration = _ACTIVE_GUARD.get()
+    if configuration is None:
+        raise ArtifactError("guarded driver factory is inactive; use activate_guarded_driver()")
+    current_receipt = resolve_frozen_binding_receipt(configuration.manifest)
+    if current_receipt.to_dict() != configuration.binding_receipt.to_dict():
+        raise ArtifactError("experiment prerequisite bindings changed after frozen preflight")
+    from .loader import resolve_driver_entrypoint
+
+    factory = resolve_driver_entrypoint(configuration.operator_entrypoint)
+    if not callable(factory):
+        raise ArtifactError("operator driver entrypoint must be a zero-argument factory")
+    try:
+        operator = factory()
+    except TypeError as exc:
+        raise ArtifactError("operator driver entrypoint must be a zero-argument factory") from exc
+    return GuardedExperimentDriver(
+        operator,
+        manifest=configuration.manifest,
+        expected_operator_fingerprint=configuration.operator_fingerprint,
+        binding_receipt=configuration.binding_receipt,
+        parity_contract=configuration.parity_contract,
+    )
+
+
+__all__ = [
+    "GuardedExperimentDriver",
+    "activate_guarded_driver",
+    "active_guarded_driver_factory",
+]

agentinputlab/experiments/drivers/__init__.py

@@ -0,0 +1,89 @@
+"""Audited experiment-driver building blocks.
+
+The package does not select a model, download an asset, or execute at import
+time.  Production factories remain operator-configured and checksum locked.
+"""
+
+from .external_arena import (
+    CONFIG_PATH_ENV as EXTERNAL_ARENA_CONFIG_PATH_ENV,
+)
+from .external_arena import (
+    CONFIG_SHA256_ENV as EXTERNAL_ARENA_CONFIG_SHA256_ENV,
+)
+from .external_arena import (
+    ExternalArenaCheckpoint,
+    ExternalArenaExperimentDriver,
+    ExternalArmPayload,
+    ExternalArmPayloadBuildRequest,
+    ExternalBridgeBuildRequest,
+    ExternalCheckpointBuildRequest,
+    ExternalUnitPreflightRequest,
+    LockedExternalArenaBuilder,
+)
+from .method_process import (
+    CONFIG_PATH_ENV as METHOD_PROCESS_CONFIG_PATH_ENV,
+)
+from .method_process import (
+    CONFIG_SHA256_ENV as METHOD_PROCESS_CONFIG_SHA256_ENV,
+)
+from .method_process import MethodProcessExperimentDriver
+from .method_process import factory as method_process_factory
+from .parity_process import (
+    CONFIG_PATH_ENV as PARITY_PROCESS_CONFIG_PATH_ENV,
+)
+from .parity_process import (
+    CONFIG_SHA256_ENV as PARITY_PROCESS_CONFIG_SHA256_ENV,
+)
+from .parity_process import (
+    ParityProcessExperimentDriver,
+    ParityProcessProtocolError,
+)
+from .parity_process import (
+    factory as parity_process_factory,
+)
+from .static_production import (
+    CONFIG_PATH_ENV,
+    CONFIG_SHA256_ENV,
+    LockedBuilderSpec,
+    StaticArmBuildRequest,
+    StaticBackendBuildRequest,
+    StaticPredictorBuildRequest,
+    StaticProductionExperimentDriver,
+    StaticRuntimeComponents,
+    factory,
+    static_predictor_product_sha256,
+    static_runtime_product_sha256,
+)
+
+__all__ = [
+    "CONFIG_PATH_ENV",
+    "CONFIG_SHA256_ENV",
+    "EXTERNAL_ARENA_CONFIG_PATH_ENV",
+    "EXTERNAL_ARENA_CONFIG_SHA256_ENV",
+    "METHOD_PROCESS_CONFIG_PATH_ENV",
+    "METHOD_PROCESS_CONFIG_SHA256_ENV",
+    "PARITY_PROCESS_CONFIG_PATH_ENV",
+    "PARITY_PROCESS_CONFIG_SHA256_ENV",
+    "ExternalArenaCheckpoint",
+    "ExternalArenaExperimentDriver",
+    "ExternalArmPayload",
+    "ExternalArmPayloadBuildRequest",
+    "ExternalBridgeBuildRequest",
+    "ExternalCheckpointBuildRequest",
+    "ExternalUnitPreflightRequest",
+    "LockedBuilderSpec",
+    "LockedExternalArenaBuilder",
+    "MethodProcessExperimentDriver",
+    "ParityProcessExperimentDriver",
+    "ParityProcessProtocolError",
+    "StaticArmBuildRequest",
+    "StaticBackendBuildRequest",
+    "StaticPredictorBuildRequest",
+    "StaticProductionExperimentDriver",
+    "StaticRuntimeComponents",
+    "factory",
+    "method_process_factory",
+    "parity_process_factory",
+    "static_predictor_product_sha256",
+    "static_runtime_product_sha256",
+]