volcano-sdk-python 0.10.3__tar.gz → 0.11.0__tar.gz

volcano_sdk_python-0.11.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.11.0"
+}

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.11.0](https://github.com/Kong/volcano-sdk-python/compare/v0.10.4...v0.11.0) (2026-09-23)
+
+
+### Features
+
+* **types:** verify installed SDK interface without external exclusions ([#293](https://github.com/Kong/volcano-sdk-python/issues/293)) ([50aac73](https://github.com/Kong/volcano-sdk-python/commit/50aac73b5c46f1f6925c9c9b010b70f9fc649ef3))
+
+## [0.10.4](https://github.com/Kong/volcano-sdk-python/compare/v0.10.3...v0.10.4) (2026-09-23)
+
+
+### Bug Fixes
+
+* **types:** validate transport payloads before facade access ([#287](https://github.com/Kong/volcano-sdk-python/issues/287)) ([60e280c](https://github.com/Kong/volcano-sdk-python/commit/60e280ca0665ea5a143dc8df69a3d3cc2bdbb481))
+
 ## [0.10.3](https://github.com/Kong/volcano-sdk-python/compare/v0.10.2...v0.10.3) (2026-09-23)
 
 

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: volcano-sdk-python
-Version: 0.10.3
+Version: 0.11.0
 Summary: Official Python SDK for Volcano
 Project-URL: Homepage, https://volcano.dev
 Project-URL: Repository, https://github.com/Kong/volcano-sdk-python

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/maintainers/releasing.md

@@ -23,6 +23,20 @@ It records each unchanged artifact's SHA256 before the release job uploads it.
 This package/example check does not replace registry installation or approved
 live platform acceptance.
 
+`poe quality` also recreates three [tox package environments](https://tox.wiki/en/latest/how-to/usage.html#use-extras)
+from a built wheel: one without extras, one with `durable`, and one that checks
+the installed wheel's complete public types with the durable extra. The small
+`tests/package/optional_dependency.py` smoke test checks that the base install
+omits the runtime and that the extra can load the engine adapter. Tox installs
+extras but cannot assert their absence or exercise the SDK's runtime bridge;
+Twine checks artifact metadata, and `uv pip check` checks dependency metadata,
+not that bridge. This is why the semantic assertions remain in a test file.
+The type environment uses basedpyright's `--verifytypes --warnings` with no
+`--ignoreexternal`, from an isolated project directory. This checks the wheel
+consumers receive rather than editable source or repository-only stubs.
+The release build job still checks only its own preserved wheel and sdist;
+the tox environments never receive its artifacts or publishing credentials.
+
 ## Build inputs
 
 `poe build` builds the sdist and then the wheel from that sdist. Quality and

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "volcano-sdk-python"
-version = "0.10.3"
+version = "0.11.0"
 description = "Official Python SDK for Volcano"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -63,6 +63,7 @@ dev = [
   "coverage==7.16.1",
   "pytest-cov==7.1.0",
   "types-behave==1.3.0.20260408",
+  "tox==4.62.0",
 ]
 
 [tool.uv]
@@ -246,7 +247,7 @@ exclude_lines = [
 partial_branches = []
 
 [tool.poe.tasks]
-quality = ["audit", "generated", "lint", "format-check", "types", "test", "coverage", "contract-check", "package-check"]
+quality = ["audit", "generated", "lint", "format-check", "types", "test", "coverage", "contract-check", "package-check", "package-extras"]
 build = "uv build --no-sources --require-hashes"
 audit = "bash scripts/audit_dependencies.sh"
 generated = "python -m scripts.check_openapi"
@@ -275,3 +276,25 @@ trap 'rm -rf "$package_dir"' EXIT
 poe build --out-dir "$package_dir"
 bash scripts/check_package.sh "" "$package_dir"
 """
+
+[tool.poe.tasks.package-extras]
+cmd = "tox run --recreate -e package-base,package-durable,package-types"
+
+[tool.tox]
+env_list = ["package-base", "package-durable", "package-types"]
+
+[tool.tox.env_run_base]
+package = "wheel"
+commands = [["python", "-I", "tests/package/optional_dependency.py", "base"]]
+
+[tool.tox.env.package-durable]
+extras = ["durable"]
+commands = [["python", "-I", "tests/package/optional_dependency.py", "durable"]]
+
+[tool.tox.env.package-types]
+extras = ["durable"]
+deps = ["basedpyright==1.40.1"]
+change_dir = "{env_tmp_dir}"
+commands = [
+  ["basedpyright", "--project", "{env_tmp_dir}", "--verifytypes", "volcano_sdk", "--warnings"],
+]

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/src/volcano_sdk/_transport.py

@@ -738,7 +738,7 @@ def _error_type(status: int) -> type[VolcanoError]:
     return VolcanoError
 
 
-def response_payload(response: TransportResponse, expected_status: int) -> Any:
+def response_payload(response: TransportResponse, expected_status: int) -> object:
     status = int(response.status_code)
     if status != expected_status:
         payload: Mapping[str, object]

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/src/volcano_sdk/durable_authoring.py

@@ -131,6 +131,24 @@ class DurableRuntimeMissingError(Exception):
         self.__cause__ = cause
 
 
+class _DurableEngine(Protocol):
+    """The operations the Volcano facade needs from the optional runtime."""
+
+    def seconds(self, value: int) -> object: ...
+
+    def step_options(self, *, retry: Retry, at_most_once: bool) -> object: ...
+
+    def wait_condition_options(self, options: WaitUntilOptions) -> object: ...
+
+    def map_options(self, options: BatchOptions | None) -> object: ...
+
+    def parallel_options(self, options: BatchOptions | None) -> object: ...
+
+    def named_branch(
+        self, run: Callable[[object], object], name: str | None
+    ) -> object: ...
+
+
 class _Engine:
     """The durable protocol, from the AWS durable execution SDK.
 
@@ -186,6 +204,101 @@ class _Engine:
             cls._loaded = cls()
         return cls._loaded
 
+    def seconds(self, value: int) -> EngineDuration:
+        """Build the runtime's duration from whole seconds."""
+        return self.duration.from_seconds(value)
+
+    def step_options(self, *, retry: Retry, at_most_once: bool) -> StepConfig:
+        """Build the runtime's step options."""
+        config: dict[str, Any] = {}
+        if at_most_once:
+            config["step_semantics"] = self.step_semantics.AT_MOST_ONCE_PER_RETRY
+        strategy = self._retry_strategy(retry)
+        if strategy is not None:
+            config["retry_strategy"] = strategy
+        return self.step_config(**config)
+
+    def _retry_strategy(self, retry: object) -> Any:
+        if retry is None or retry is True:
+            return None
+        # False disables the runtime's default retry policy for this step.
+        if retry is False:
+            return self._never_retry()
+        if isinstance(retry, RetryOptions):
+            return self.create_retry_strategy(
+                self.retry_strategy_config(**self._retry_kwargs(retry))
+            )
+        if callable(retry):
+            return retry
+        raise TypeError(_INVALID_RETRY)
+
+    def _never_retry(self) -> Callable[[Exception, int], RetryDecision]:
+        no_delay = self.seconds(0)
+
+        def never_retry(_error: Exception, _attempt: int) -> RetryDecision:
+            return self.retry_decision(should_retry=False, delay=no_delay)
+
+        return never_retry
+
+    def _retry_kwargs(self, retry: RetryOptions) -> dict[str, Any]:
+        return _engine_kwargs(
+            max_attempts=retry.attempts,
+            initial_delay=self._optional_duration(retry.initial_delay, "initial_delay"),
+            max_delay=self._optional_duration(retry.max_delay, "max_delay"),
+            backoff_rate=retry.backoff_rate,
+            retryable_errors=(None if retry.retry_on is None else list(retry.retry_on)),
+            retryable_error_types=(
+                None if retry.retry_on_types is None else list(retry.retry_on_types)
+            ),
+        )
+
+    def _optional_duration(
+        self, value: Duration | None, field_name: str
+    ) -> EngineDuration | None:
+        return None if value is None else self.seconds(_to_seconds(value, field_name))
+
+    def wait_condition_options(self, options: WaitUntilOptions) -> object:
+        """Build the runtime's polling options."""
+        until = options.until
+
+        def keep_polling(state: Any) -> bool:
+            return not until(state)
+
+        strategy = self.wait_strategy_config(
+            **_engine_kwargs(
+                should_continue_polling=keep_polling,
+                max_attempts=options.max_attempts,
+                initial_delay=self._optional_duration(options.interval, "interval"),
+                max_delay=self._optional_duration(options.max_interval, "max_interval"),
+                backoff_rate=options.backoff_rate,
+            )
+        )
+        return self.wait_for_condition_config(
+            wait_strategy=self.create_wait_strategy(strategy),
+            initial_state=options.initial_state,
+        )
+
+    def _batch_options(self, options: BatchOptions | None) -> dict[str, Any]:
+        resolved = BatchOptions() if options is None else options
+        config = _engine_kwargs(max_concurrency=resolved.concurrency)
+        if resolved.min_succeeded is not None:
+            config["completion_config"] = self.completion_config(
+                min_successful=resolved.min_succeeded
+            )
+        return config
+
+    def map_options(self, options: BatchOptions | None) -> object:
+        """Build the runtime's map options."""
+        return self.map_config(**self._batch_options(options))
+
+    def parallel_options(self, options: BatchOptions | None) -> ParallelConfig:
+        """Build the runtime's parallel options."""
+        return self.parallel_config(**self._batch_options(options))
+
+    def named_branch(self, run: Callable[[object], object], name: str | None) -> object:
+        """Build a named runtime branch."""
+        return self.parallel_branch(func=run, name=name)
+
 
 @dataclass(frozen=True, slots=True)
 class RetryOptions:
@@ -436,7 +549,7 @@ class DurableContext:
 
     __slots__ = ("_context", "_engine", "log")
 
-    def __init__(self, context: Any, engine: _Engine) -> None:
+    def __init__(self, context: Any, engine: _DurableEngine) -> None:
         """Wrap an engine context."""
         self._context = context
         self._engine = engine
@@ -478,7 +591,7 @@ class DurableContext:
             self._context.step(
                 run,
                 step_name,
-                self._step_config(retry=retry, at_most_once=at_most_once),
+                self._engine.step_options(retry=retry, at_most_once=at_most_once),
             ),
         )
 
@@ -543,29 +656,13 @@ class DurableContext:
         check_func = _callable(check, "wait_until")
         _validate_wait_options(options)
         engine = self._engine
-        until = options.until
-
-        def keep_polling(state: Any) -> bool:
-            return not until(state)
 
         def check_state(state: Any, scope: Any) -> Any:
             return check_func(state, StepScope(scope.logger, scope.attempt))
 
-        strategy = engine.wait_strategy_config(
-            **_engine_kwargs(
-                should_continue_polling=keep_polling,
-                max_attempts=options.max_attempts,
-                initial_delay=self._optional_duration(options.interval, "interval"),
-                max_delay=self._optional_duration(options.max_interval, "max_interval"),
-                backoff_rate=options.backoff_rate,
-            )
-        )
         return self._context.wait_for_condition(
             check_state,
-            engine.wait_for_condition_config(
-                wait_strategy=engine.create_wait_strategy(strategy),
-                initial_state=options.initial_state,
-            ),
+            engine.wait_condition_options(options),
             name,
         )
 
@@ -601,7 +698,7 @@ class DurableContext:
                 list(items),
                 run,
                 name,
-                engine.map_config(**self._batch_config(options)),
+                engine.map_options(options),
             )
         )
 
@@ -623,7 +720,7 @@ class DurableContext:
             self._context.parallel(
                 [self._branch(branch) for branch in branches],
                 name,
-                engine.parallel_config(**self._batch_config(options)),
+                engine.parallel_options(options),
             )
         )
 
@@ -650,7 +747,7 @@ class DurableContext:
             def run_named(context: Any) -> Any:
                 return named(DurableContext(context, engine))
 
-            return engine.parallel_branch(func=run_named, name=branch.name)
+            return engine.named_branch(run_named, branch.name)
         require_callable(branch, _INVALID_BRANCH)
         bare = branch
 
@@ -659,72 +756,7 @@ class DurableContext:
 
         return run_bare
 
-    def _batch_config(self, options: BatchOptions | None) -> dict[str, Any]:
-        resolved = BatchOptions() if options is None else options
-        config = _engine_kwargs(max_concurrency=resolved.concurrency)
-        if resolved.min_succeeded is not None:
-            config["completion_config"] = self._engine.completion_config(
-                min_successful=resolved.min_succeeded
-            )
-        return config
-
-    def _step_config(self, *, retry: Retry, at_most_once: bool) -> StepConfig:
-        engine = self._engine
-        config: dict[str, Any] = {}
-        if at_most_once:
-            config["step_semantics"] = engine.step_semantics.AT_MOST_ONCE_PER_RETRY
-        strategy = self._retry_strategy(retry)
-        if strategy is not None:
-            config["retry_strategy"] = strategy
-        return engine.step_config(**config)
-
-    def _retry_strategy(self, retry: object) -> Any:
-        engine = self._engine
-        if retry is None or retry is True:
-            return None
-        # retry=False means "fail on the first error", which is not the same as
-        # leaving retry unset: the platform retries by default, and a step that
-        # is not safe to repeat wants the opposite.
-        if retry is False:
-            return self._never_retry()
-        if isinstance(retry, RetryOptions):
-            return engine.create_retry_strategy(
-                engine.retry_strategy_config(**self._retry_kwargs(retry))
-            )
-        if callable(retry):
-            return retry
-        raise TypeError(_INVALID_RETRY)
-
-    def _never_retry(self) -> Callable[[Exception, int], RetryDecision]:
-        engine = self._engine
-        no_delay = engine.duration.from_seconds(0)
-
-        def never_retry(_error: Exception, _attempt: int) -> RetryDecision:
-            return engine.retry_decision(should_retry=False, delay=no_delay)
-
-        return never_retry
-
-    def _retry_kwargs(self, retry: RetryOptions) -> dict[str, Any]:
-        return _engine_kwargs(
-            max_attempts=retry.attempts,
-            initial_delay=self._optional_duration(retry.initial_delay, "initial_delay"),
-            max_delay=self._optional_duration(retry.max_delay, "max_delay"),
-            backoff_rate=retry.backoff_rate,
-            retryable_errors=(None if retry.retry_on is None else list(retry.retry_on)),
-            retryable_error_types=(
-                None if retry.retry_on_types is None else list(retry.retry_on_types)
-            ),
-        )
-
-    def _optional_duration(
-        self, value: Duration | None, field_name: str
-    ) -> EngineDuration | None:
-        return None if value is None else self._duration(value, field_name)
-
-    def _duration(self, value: object, field_name: str) -> EngineDuration:
-        return self._engine.duration.from_seconds(_to_seconds(value, field_name))
-
-    def _wait_duration(self, value: object) -> EngineDuration:
+    def _wait_duration(self, value: object) -> object:
         seconds = _to_seconds(value, "wait")
         if seconds < _MIN_WAIT_SECONDS:
             message = f"wait must be at least {_MIN_WAIT_SECONDS} second"
@@ -732,7 +764,7 @@ class DurableContext:
         if seconds > _MAX_WAIT_SECONDS:
             message = f"wait must be at most {_MAX_WAIT_SECONDS} seconds (366 days)"
             raise TypeError(message)
-        return self._engine.duration.from_seconds(seconds)
+        return self._engine.seconds(seconds)
 
 
 @overload

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/src/volcano_sdk/locks.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from contextlib import contextmanager, suppress
 from datetime import datetime
 from typing import TYPE_CHECKING, Protocol, cast
@@ -22,6 +23,7 @@ _MIN_LOCK_TTL_SECONDS = 5
 _MAX_LOCK_TTL_SECONDS = 7_776_000
 _INVALID_LOCK_TTL = "ttl must be an integer between 5 seconds and 90 days"
 _MISSING_RENEWAL_FAILURE = "lock guard rejected renewal without a failure"
+_INVALID_LOCK_RESPONSE = "Expected a complete lock response"
 
 
 class LocksContext(Protocol):
@@ -82,6 +84,26 @@ def _parse_datetime(value: object) -> datetime | None:
     return datetime.fromisoformat(str(value))
 
 
+def _lock_values(payload: object) -> Mapping[object, object]:
+    if not isinstance(payload, Mapping):
+        raise TypeError(_INVALID_LOCK_RESPONSE)
+    return cast("Mapping[object, object]", payload)
+
+
+def _fencing_token(value: object) -> int | None:
+    if value is None or type(value) is int:
+        return value
+    raise TypeError(_INVALID_LOCK_RESPONSE)
+
+
+def _lease_fields(payload: Mapping[object, object]) -> tuple[datetime, int]:
+    expires_at = payload.get("expires_at")
+    fencing_token = payload.get("fencing_token")
+    if not isinstance(expires_at, str) or type(fencing_token) is not int:
+        raise TypeError(_INVALID_LOCK_RESPONSE)
+    return datetime.fromisoformat(expires_at), fencing_token
+
+
 def _validate_ttl(ttl: object) -> None:
     if (
         isinstance(ttl, bool)
@@ -125,11 +147,14 @@ class Locks:
             key=key,
             request_id=_request_uuid(request_id, "request_id"),
         )
-        payload = response_payload(response, 200)
+        payload = _lock_values(response_payload(response, 200))
+        held = payload.get("held")
+        if not isinstance(held, bool):
+            raise TypeError(_INVALID_LOCK_RESPONSE)
         return LockState(
-            held=payload["held"],
+            held=held,
             expires_at=_parse_datetime(payload.get("expires_at")),
-            fencing_token=payload.get("fencing_token"),
+            fencing_token=_fencing_token(payload.get("fencing_token")),
         )
 
     def acquire(
@@ -173,17 +198,18 @@ class Locks:
                 raise
             started_at = _lease_now()
             payload = self._acquire_payload(key, ttl, token, request_id, authorization)
+        expires_at, fencing_token = _lease_fields(payload)
         lease = LockLease(
             key=key,
             token=token,
-            expires_at=_parse_datetime(payload.get("expires_at")),
-            fencing_token=cast("int | None", payload.get("fencing_token")),
+            expires_at=expires_at,
+            fencing_token=fencing_token,
         )
         return lease, started_at
 
     def _acquire_payload(
         self, key: str, ttl: int, token: str, request_id: str, authorization: str
-    ) -> dict[str, object]:
+    ) -> Mapping[object, object]:
         response = invoke(
             self._client._transport.acquire_project_lock,
             authorization=authorization,
@@ -192,7 +218,7 @@ class Locks:
             token=token,
             request_id=request_id,
         )
-        return cast("dict[str, object]", response_payload(response, 201))
+        return _lock_values(response_payload(response, 201))
 
     def renew(
         self, key: str, lease: LockLease, *, ttl: int, request_id: str | None = None
@@ -216,12 +242,13 @@ class Locks:
             ttl=ttl,
             token=lease.token,
         )
-        payload = response_payload(response, 200)
+        payload = _lock_values(response_payload(response, 200))
+        expires_at, fencing_token = _lease_fields(payload)
         return LockLease(
             key=key,
             token=lease.token,
-            expires_at=_parse_datetime(payload.get("expires_at")),
-            fencing_token=payload.get("fencing_token"),
+            expires_at=expires_at,
+            fencing_token=fencing_token,
         )
 
     def release(

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/src/volcano_sdk/realtime.py

@@ -35,6 +35,7 @@ from ._transport import (
     invoke_async,
     response_payload,
 )
+from .database import _database_rows
 from .models import JSONValue, _freeze_json
 
 if TYPE_CHECKING:
@@ -1391,8 +1392,7 @@ class Realtime:
                 "limit": len(row_ids),
             },
         )
-        payload = response_payload(response, 200)
-        rows = list(payload["data"])
+        rows = _database_rows(response_payload(response, 200))
         return tuple(
             next(
                 (row for row in rows if row.get("id") == request.row_id),

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/src/volcano_sdk/storage.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from io import SEEK_END, BytesIO
 from tempfile import TemporaryFile
-from typing import TYPE_CHECKING, Any, BinaryIO, Protocol, TypeGuard, cast
+from typing import TYPE_CHECKING, BinaryIO, Protocol, TypeGuard, cast
 from urllib.parse import quote
 
 from ._transport import (
@@ -50,6 +50,7 @@ _HTTP_PARTIAL_CONTENT = 206
 _UPLOAD_SPOOL_READ_SIZE = 1_048_576
 _UPLOAD_SOURCE_UNAVAILABLE = "Upload source is temporarily unavailable"
 _INVALID_SIMPLE_UPLOAD = "Upload data must be bytes or a readable binary stream"
+_INVALID_UPLOAD_RESPONSE = "Expected a storage upload response object"
 
 
 def _optional_datetime(value: object) -> datetime | None:
@@ -462,6 +463,13 @@ def _upload_content_type(value: object) -> str:
     return value
 
 
+def _is_string_keyed_mapping(value: object) -> TypeGuard[Mapping[str, object]]:
+    if not isinstance(value, Mapping):
+        return False
+    mapping = cast("Mapping[object, object]", value)
+    return all(isinstance(key, str) for key in mapping)
+
+
 @dataclass(frozen=True, slots=True)
 class StorageBucket:
     """Operations scoped to one storage bucket."""
@@ -475,7 +483,7 @@ class StorageBucket:
         data: bytes | BinaryIO,
         *,
         content_type: str | None = None,
-    ) -> dict[str, Any]:
+    ) -> dict[str, object]:
         """Upload bytes or the remaining contents of a binary stream.
 
         Returns:
@@ -498,6 +506,8 @@ class StorageBucket:
             binding=binding,
         )
         payload = response_payload(response, 201)
+        if not _is_string_keyed_mapping(payload):
+            raise TypeError(_INVALID_UPLOAD_RESPONSE)
         return dict(payload)
 
     def download(self, path: str, *, byte_range: str | None = None) -> bytes:

volcano_sdk_python-0.11.0/tests/package/optional_dependency.py

@@ -0,0 +1,25 @@
+"""Check the installed wheel with and without its durable extra."""
+
+from __future__ import annotations
+
+import sys
+from importlib.util import find_spec
+
+from volcano_sdk.durable_authoring import _Engine, durable
+
+
+def main() -> None:
+    """Exercise the optional runtime in a package environment managed by tox."""
+    assert callable(durable)
+    installed = find_spec("aws_durable_execution_sdk_python") is not None
+    if sys.argv[1] == "base":
+        assert not installed
+    elif sys.argv[1] == "durable":
+        assert installed
+        _Engine.load()
+    else:
+        raise ValueError(sys.argv[1])
+
+
+if __name__ == "__main__":
+    main()

{volcano_sdk_python-0.10.3 → volcano_sdk_python-0.11.0}/tests/typing/durable_configuration.py

@@ -1,4 +1,4 @@
-"""The optional engine exposes concrete configuration and duration types."""
+"""The optional engine retains concrete types behind the facade boundary."""
 
 from __future__ import annotations
 
@@ -14,10 +14,12 @@ from aws_durable_execution_sdk_python.config import Duration as EngineDuration
 from aws_durable_execution_sdk_python.retries import RetryDecision, RetryStrategyConfig
 
 if TYPE_CHECKING:
-    from volcano_sdk.durable_authoring import DurableContext, _Engine
+    from volcano_sdk.durable_authoring import DurableContext, _DurableEngine, _Engine
 
 
 def configuration_types(engine: _Engine, context: DurableContext) -> None:
+    interface: _DurableEngine = engine
+    interface.seconds(5)
     delay = engine.duration.from_seconds(5)
     assert_type(delay, EngineDuration)
     assert_type(engine.step_config(), StepConfig)
@@ -26,11 +28,11 @@ def configuration_types(engine: _Engine, context: DurableContext) -> None:
     assert_type(engine.completion_config(), CompletionConfig)
     assert_type(engine.retry_strategy_config(), RetryStrategyConfig)
     assert_type(engine.retry_decision(should_retry=False, delay=delay), RetryDecision)
-    assert_type(context._step_config(retry=False, at_most_once=True), StepConfig)
-    assert_type(context._never_retry()(ValueError("failure"), 1), RetryDecision)
-    assert_type(context._duration("5s", "interval"), EngineDuration)
-    assert_type(context._wait_duration("5s"), EngineDuration)
-    assert_type(context._optional_duration(None, "interval"), EngineDuration | None)
+    assert_type(engine.step_options(retry=False, at_most_once=True), StepConfig)
+    assert_type(engine._never_retry()(ValueError("failure"), 1), RetryDecision)
+    assert_type(engine.seconds(5), EngineDuration)
+    assert_type(context._wait_duration("5s"), object)
+    assert_type(engine._optional_duration(None, "interval"), EngineDuration | None)
 
 
 def invalid_configuration(engine: _Engine) -> None: