dex-python-sdk 0.0.2__tar.gz → 0.1.1__tar.gz

{dex_python_sdk-0.0.2 → dex_python_sdk-0.1.1}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: dex-python-sdk
-Version: 0.0.2
+Version: 0.1.1
 Requires-Dist: grpcio>=1.83.0
 Requires-Dist: grpcio-status>=1.83.0
-Requires-Dist: httpx==0.28.1
 Requires-Dist: protobuf>=7.35.1
 License-File: LICENSE
 License-File: LEGACY_NOTICES.md
@@ -88,7 +87,7 @@ options = (
 ```
 
 ```
-pip install dex-python-sdk==0.0.2
+pip install dex-python-sdk==0.1.0
 ```
 
 See [samples](../examples/python) for use case examples.
@@ -100,14 +99,16 @@ See [samples](../examples/python) for use case examples.
 
 ## Concepts
 
-Applications implement two generic interfaces from [`dex.contracts`](dex/contracts/):
+Applications implement two generic interfaces from [`dex`](dex/):
 
 - `Flow[START_INPUT]` returns `StepList.start_step(...)`, followed by optional
   `.other_steps(...)`, from one `get_steps()` method. The `StepList` generic
   binds the Flow input to the starting Step input. Use `StepList.empty()` when
   a Flow has no Steps.
-- `Step[INPUT]` implements synchronous `execute` and optionally synchronous
-  `wait_for`.
+- `Step[INPUT]` implements `execute` and optionally `wait_for`. The default
+  Worker path requires synchronous handlers. With `AsyncWorker` and
+  `Registry(..., allow_async_handlers=True)`, handlers may be `async def` and
+  `await` an `AsyncClient`.
 
 `StepOptions.wait_for_method_timeout` and `execute_method_timeout` bound the
 two handler calls. Timer and channel conditions determine how long a Step waits.
@@ -116,16 +117,30 @@ two handler calls. Timer and channel conditions determine how long a Step waits.
 codec before Client or Worker startup. `Client` methods use these typed objects
 instead of raw Flow, Step, or RPC strings.
 
-The legacy IWF integration inventory is ported under
-[`tests/integ`](tests/integ/README.md). Its 58 executable scenarios
-exercise the same workflows, client operations, and assertions as the Java
-suite against an isolated `dexcli dev` environment.
+### Sync vs asyncio
+
+- **Sync (default):** `Client` and `Worker` use blocking gRPC and a thread-pool
+  Worker. Blocking `Client` calls inside `Step.execute` are safe (one pool
+  thread is occupied; other RPCs still run).
+- **Asyncio:** `AsyncClient` and `AsyncWorker` use `grpc.aio`. Use
+  `Registry(..., allow_async_handlers=True)` when Steps/RPCs are coroutines.
+  Inside async `execute`, inject `AsyncClient` — do not call sync `Client` on
+  the Worker event loop. Sync `Worker` still rejects coroutine handlers at
+  registry construction unless `allow_async_handlers=True` (and even then the
+  sync Worker dispatcher rejects awaitable return values).
+
+Integration scenarios live under
+[`tests/integ`](tests/integ/README.md). They exercise the same workflows,
+client operations, and assertions as the Java suite against an isolated
+`dexcli dev` environment.
 
 ## Implementation status
 
-The strongly typed contracts, registry, synchronous Client, Worker gRPC
-service, and Rust-backed BlobCache are implemented. Python owns its gRPC
-transport; the native bridge is limited to the shared BlobCache.
+The strongly typed contracts, registry, synchronous Client/Worker, optional
+`AsyncClient`/`AsyncWorker` (`grpc.aio`), and Rust-backed BlobCache are
+implemented. Python owns its gRPC transport; the native bridge is limited to
+the shared BlobCache. Design notes:
+[`docs/design/plan/python-sdk-async-apis.md`](../docs/design/plan/python-sdk-async-apis.md).
 
 ## Running dex-server locally
 
@@ -162,6 +177,25 @@ environment:
 ./run-integration-tests.sh
 ```
 
+### Measure integration coverage
+
+Run the same integration suite with Python source coverage:
+
+```bash
+./run-integration-tests.sh --coverage
+```
+
+Only the integration scenarios contribute execution data, and only production
+Python modules under `dex` are measured. Generated protobuf modules under
+`dex/dexpb` are excluded. The
+terminal report lists uncovered line ranges. The browser report starts at
+`coverage/html/index.html`; `coverage/coverage.xml` and `coverage/lcov.info`
+are also generated.
+
+CI uploads LCOV to Codecov with GitHub OIDC under the
+`sdk-python-integration` flag and retains the full report as the
+`sdk-python-integration-coverage` Actions artifact.
+
 #### Update IDL
 
 Edit [`protos/dex.proto`](../protos/dex.proto). Rename catalog: [`docs/design/idl-renames.md`](../docs/design/idl-renames.md).
@@ -186,12 +220,17 @@ This project is governed by the [Contributor Covenant v 1.4.1](CODE_OF_CONDUCT.m
 
 ## Publishing to PyPI
 
-1. Bump `version` in `pyproject.toml`, refresh `uv.lock`, and update the `pip install` line above.
-2. Run **Publish Python SDK to PyPI** manually without `publish` to validate all distributions.
-3. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.0.2`).
-4. CI builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and Windows x86_64 wheels, verifies the source distribution, and publishes them with `PYPI_TOKEN`.
-
-A manual run publishes only from `main`, when its version matches `pyproject.toml` and `publish` is explicitly selected.
+1. Optionally run **Publish Python SDK to PyPI** via workflow_dispatch with a version and
+   `publish=false` to validate all distributions without uploading.
+2. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.1.0`).
+   CI stamps that version into `pyproject.toml` for the build (same idea as the TypeScript
+   SDK release), then builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and
+   Windows x86_64 wheels, verifies the source distribution, and publishes with `PYPI_TOKEN`.
+3. After publishing, bump the committed `pyproject.toml` / docs install line when you want
+   the repo tip to reflect the released version.
+
+A manual run publishes only from `main`, and only when `publish` is explicitly selected.
+The dispatch `version` input is stamped the same way as a release tag.
 
 See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo tag conventions.
 

{dex_python_sdk-0.0.2 → dex_python_sdk-0.1.1}/README.md

@@ -71,7 +71,7 @@ options = (
 ```
 
 ```
-pip install dex-python-sdk==0.0.2
+pip install dex-python-sdk==0.1.0
 ```
 
 See [samples](../examples/python) for use case examples.
@@ -83,14 +83,16 @@ See [samples](../examples/python) for use case examples.
 
 ## Concepts
 
-Applications implement two generic interfaces from [`dex.contracts`](dex/contracts/):
+Applications implement two generic interfaces from [`dex`](dex/):
 
 - `Flow[START_INPUT]` returns `StepList.start_step(...)`, followed by optional
   `.other_steps(...)`, from one `get_steps()` method. The `StepList` generic
   binds the Flow input to the starting Step input. Use `StepList.empty()` when
   a Flow has no Steps.
-- `Step[INPUT]` implements synchronous `execute` and optionally synchronous
-  `wait_for`.
+- `Step[INPUT]` implements `execute` and optionally `wait_for`. The default
+  Worker path requires synchronous handlers. With `AsyncWorker` and
+  `Registry(..., allow_async_handlers=True)`, handlers may be `async def` and
+  `await` an `AsyncClient`.
 
 `StepOptions.wait_for_method_timeout` and `execute_method_timeout` bound the
 two handler calls. Timer and channel conditions determine how long a Step waits.
@@ -99,16 +101,30 @@ two handler calls. Timer and channel conditions determine how long a Step waits.
 codec before Client or Worker startup. `Client` methods use these typed objects
 instead of raw Flow, Step, or RPC strings.
 
-The legacy IWF integration inventory is ported under
-[`tests/integ`](tests/integ/README.md). Its 58 executable scenarios
-exercise the same workflows, client operations, and assertions as the Java
-suite against an isolated `dexcli dev` environment.
+### Sync vs asyncio
+
+- **Sync (default):** `Client` and `Worker` use blocking gRPC and a thread-pool
+  Worker. Blocking `Client` calls inside `Step.execute` are safe (one pool
+  thread is occupied; other RPCs still run).
+- **Asyncio:** `AsyncClient` and `AsyncWorker` use `grpc.aio`. Use
+  `Registry(..., allow_async_handlers=True)` when Steps/RPCs are coroutines.
+  Inside async `execute`, inject `AsyncClient` — do not call sync `Client` on
+  the Worker event loop. Sync `Worker` still rejects coroutine handlers at
+  registry construction unless `allow_async_handlers=True` (and even then the
+  sync Worker dispatcher rejects awaitable return values).
+
+Integration scenarios live under
+[`tests/integ`](tests/integ/README.md). They exercise the same workflows,
+client operations, and assertions as the Java suite against an isolated
+`dexcli dev` environment.
 
 ## Implementation status
 
-The strongly typed contracts, registry, synchronous Client, Worker gRPC
-service, and Rust-backed BlobCache are implemented. Python owns its gRPC
-transport; the native bridge is limited to the shared BlobCache.
+The strongly typed contracts, registry, synchronous Client/Worker, optional
+`AsyncClient`/`AsyncWorker` (`grpc.aio`), and Rust-backed BlobCache are
+implemented. Python owns its gRPC transport; the native bridge is limited to
+the shared BlobCache. Design notes:
+[`docs/design/plan/python-sdk-async-apis.md`](../docs/design/plan/python-sdk-async-apis.md).
 
 ## Running dex-server locally
 
@@ -145,6 +161,25 @@ environment:
 ./run-integration-tests.sh
 ```
 
+### Measure integration coverage
+
+Run the same integration suite with Python source coverage:
+
+```bash
+./run-integration-tests.sh --coverage
+```
+
+Only the integration scenarios contribute execution data, and only production
+Python modules under `dex` are measured. Generated protobuf modules under
+`dex/dexpb` are excluded. The
+terminal report lists uncovered line ranges. The browser report starts at
+`coverage/html/index.html`; `coverage/coverage.xml` and `coverage/lcov.info`
+are also generated.
+
+CI uploads LCOV to Codecov with GitHub OIDC under the
+`sdk-python-integration` flag and retains the full report as the
+`sdk-python-integration-coverage` Actions artifact.
+
 #### Update IDL
 
 Edit [`protos/dex.proto`](../protos/dex.proto). Rename catalog: [`docs/design/idl-renames.md`](../docs/design/idl-renames.md).
@@ -169,12 +204,17 @@ This project is governed by the [Contributor Covenant v 1.4.1](CODE_OF_CONDUCT.m
 
 ## Publishing to PyPI
 
-1. Bump `version` in `pyproject.toml`, refresh `uv.lock`, and update the `pip install` line above.
-2. Run **Publish Python SDK to PyPI** manually without `publish` to validate all distributions.
-3. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.0.2`).
-4. CI builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and Windows x86_64 wheels, verifies the source distribution, and publishes them with `PYPI_TOKEN`.
-
-A manual run publishes only from `main`, when its version matches `pyproject.toml` and `publish` is explicitly selected.
+1. Optionally run **Publish Python SDK to PyPI** via workflow_dispatch with a version and
+   `publish=false` to validate all distributions without uploading.
+2. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.1.0`).
+   CI stamps that version into `pyproject.toml` for the build (same idea as the TypeScript
+   SDK release), then builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and
+   Windows x86_64 wheels, verifies the source distribution, and publishes with `PYPI_TOKEN`.
+3. After publishing, bump the committed `pyproject.toml` / docs install line when you want
+   the repo tip to reflect the released version.
+
+A manual run publishes only from `main`, and only when `publish` is explicitly selected.
+The dispatch `version` input is stamped the same way as a release tag.
 
 See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo tag conventions.
 

{dex_python_sdk-0.0.2 → dex_python_sdk-0.1.1}/dex/__init__.py

@@ -17,6 +17,8 @@ from dex.attribute import (
 )
 from dex.blob_cache import BlobCache, BlobCacheConfig, open_blob_cache
 from dex.channel import Channel, ChannelMap
+from dex.async_client import AsyncClient
+from dex.async_worker import AsyncWorker
 from dex.client import Client
 from dex.client_options import ClientOptions
 from dex.codec import (
@@ -35,7 +37,13 @@ from dex.condition import ConditionCombination
 from dex.context import Context
 from dex.flow import Flow, PersistenceSchema, Registry, RPCResult, rpc
 from dex.flow_config import ActiveStepSearchMode, FlowConfig
-from dex.flow_info import FlowInfo, FlowStatus, HealthInfo, SearchFlowEntry
+from dex.flow_info import (
+    FlowInfo,
+    FlowStatus,
+    HealthInfo,
+    SearchFlowEntry,
+    SearchFlowsPage,
+)
 from dex.flow_options import (
     IdReusePolicy,
     ResetFlowOptions,
@@ -85,6 +93,8 @@ __all__ = [
     "AttributeIndex",
     "AttributeLock",
     "AttributeMap",
+    "AsyncClient",
+    "AsyncWorker",
     "BlobCache",
     "BlobCacheConfig",
     "Channel",
@@ -115,6 +125,7 @@ __all__ = [
     "ResetType",
     "RetryPolicy",
     "SearchFlowEntry",
+    "SearchFlowsPage",
     "StartFlowOptions",
     "StepExecutionId",
     "StepDecision",

dex_python_sdk-0.1.1/dex/_async_value_hydrator.py

@@ -0,0 +1,223 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+from dex.blob_cache import BlobCache
+from dex.dexpb import dex_pb2 as pb
+from dex.dexpb import dex_pb2_grpc
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class _PendingBlob:
+    blob_id: str
+    is_object: bool
+    request: pb.Value
+    indexes: list[int] = field(default_factory=list)
+    hydrated: pb.Value | None = None
+
+
+class AsyncValueHydrator:
+    def __init__(
+        self,
+        service: dex_pb2_grpc.FlowServiceStub,
+        cache: BlobCache,
+    ) -> None:
+        self._service = service
+        self._cache = cache
+
+    async def hydrate(self, value: pb.Value) -> pb.Value:
+        return (await self.hydrate_all([value]))[0]
+
+    async def hydrate_all(self, values: list[pb.Value]) -> list[pb.Value]:
+        hydrated = list(values)
+        pending: dict[tuple[str, bool], _PendingBlob] = {}
+        for index, value in enumerate(values):
+            key = self._blob_key(value)
+            if key is None:
+                self._validate_concrete(value)
+                continue
+            blob = pending.get(key)
+            if blob is None:
+                blob = _PendingBlob(key[0], key[1], value)
+                pending[key] = blob
+            blob.indexes.append(index)
+
+        misses: list[_PendingBlob] = []
+        for blob in pending.values():
+            concrete = self._read_cache(blob)
+            if concrete is None:
+                misses.append(blob)
+            else:
+                blob.hydrated = concrete
+        await self._load_misses(misses)
+
+        for blob in pending.values():
+            if blob.hydrated is None:
+                raise RuntimeError(f"blob was not hydrated: {blob.blob_id}")
+            for index in blob.indexes:
+                hydrated[index] = blob.hydrated
+        return hydrated
+
+    async def wait_for_request(
+        self,
+        request: pb.InvokeWaitForMethodRequest,
+    ) -> pb.InvokeWaitForMethodRequest:
+        result = pb.InvokeWaitForMethodRequest()
+        result.CopyFrom(request)
+        values = [request.step_input, *(entry.value for entry in request.attributes)]
+        hydrated = await self.hydrate_all(values)
+        result.step_input.CopyFrom(hydrated[0])
+        for entry, value in zip(result.attributes, hydrated[1:]):
+            entry.value.CopyFrom(value)
+        return result
+
+    async def execute_request(
+        self,
+        request: pb.InvokeExecuteMethodRequest,
+    ) -> pb.InvokeExecuteMethodRequest:
+        result = pb.InvokeExecuteMethodRequest()
+        result.CopyFrom(request)
+        values = [request.step_input]
+        values.extend(entry.value for entry in request.attributes)
+        values.extend(entry.value for entry in request.step_exe_locals)
+        for channel_result in request.condition_results.channel_results:
+            values.extend(channel_result.values)
+        hydrated = iter(await self.hydrate_all(values))
+        result.step_input.CopyFrom(next(hydrated))
+        for entry in result.attributes:
+            entry.value.CopyFrom(next(hydrated))
+        for entry in result.step_exe_locals:
+            entry.value.CopyFrom(next(hydrated))
+        for channel_result in result.condition_results.channel_results:
+            for value in channel_result.values:
+                value.CopyFrom(next(hydrated))
+        return result
+
+    async def rpc_request(
+        self,
+        request: pb.InvokeWorkerRPCRequest,
+    ) -> pb.InvokeWorkerRPCRequest:
+        result = pb.InvokeWorkerRPCRequest()
+        result.CopyFrom(request)
+        values = [request.input, *(entry.value for entry in request.attributes)]
+        hydrated = await self.hydrate_all(values)
+        result.input.CopyFrom(hydrated[0])
+        for entry, value in zip(result.attributes, hydrated[1:]):
+            entry.value.CopyFrom(value)
+        return result
+
+    async def step_outputs(
+        self,
+        outputs: list[pb.StepCompletionOutput],
+    ) -> list[pb.StepCompletionOutput]:
+        values = [output.completed_step_output for output in outputs]
+        hydrated = await self.hydrate_all(values)
+        results: list[pb.StepCompletionOutput] = []
+        for output, value in zip(outputs, hydrated):
+            result = pb.StepCompletionOutput()
+            result.CopyFrom(output)
+            result.completed_step_output.CopyFrom(value)
+            results.append(result)
+        return results
+
+    async def _load_misses(self, misses: list[_PendingBlob]) -> None:
+        if not misses:
+            return
+        response = await self._service.LoadBlobs(
+            pb.LoadBlobsRequest(values=[miss.request for miss in misses])
+        )
+        for miss in misses:
+            concrete = response.values.get(miss.blob_id)
+            if concrete is None:
+                raise RuntimeError(f"LoadBlobs omitted blob {miss.blob_id}")
+            self._validate_hydrated(miss, concrete)
+            miss.hydrated = concrete
+            self._write_cache(miss, concrete)
+
+    def _read_cache(self, blob: _PendingBlob) -> pb.Value | None:
+        try:
+            payload = self._cache.get(blob.blob_id)
+            if payload is None:
+                return None
+            if blob.is_object:
+                concrete = pb.Value(obj_value=pb.EncodedObject.FromString(payload))
+            else:
+                concrete = pb.Value(string_value=payload.decode("utf-8"))
+            self._validate_hydrated(blob, concrete)
+            return concrete
+        except Exception:
+            _LOGGER.warning("cannot read cached blob %s", blob.blob_id, exc_info=True)
+            try:
+                self._cache.delete(blob.blob_id)
+            except Exception:
+                _LOGGER.warning(
+                    "cannot delete cached blob %s",
+                    blob.blob_id,
+                    exc_info=True,
+                )
+            return None
+
+    def _write_cache(self, blob: _PendingBlob, concrete: pb.Value) -> None:
+        try:
+            payload = (
+                concrete.obj_value.SerializeToString()
+                if blob.is_object
+                else concrete.string_value.encode("utf-8")
+            )
+            self._cache.put(blob.blob_id, payload)
+        except Exception:
+            _LOGGER.warning("cannot cache blob %s", blob.blob_id, exc_info=True)
+
+    @staticmethod
+    def _blob_key(value: pb.Value) -> tuple[str, bool] | None:
+        kind = value.WhichOneof("kind")
+        if kind == "internal_blob_id_for_string_value":
+            blob_id = value.internal_blob_id_for_string_value
+            if not blob_id:
+                raise ValueError("blob ID is required")
+            return blob_id, False
+        if kind == "internal_blob_id_for_obj_value":
+            blob_id = value.internal_blob_id_for_obj_value
+            if not blob_id:
+                raise ValueError("blob ID is required")
+            return blob_id, True
+        return None
+
+    @staticmethod
+    def _validate_hydrated(blob: _PendingBlob, value: pb.Value) -> None:
+        expected = "obj_value" if blob.is_object else "string_value"
+        if value.WhichOneof("kind") != expected:
+            raise RuntimeError(
+                f"blob {blob.blob_id} hydrated to {value.WhichOneof('kind')}"
+            )
+        AsyncValueHydrator._validate_concrete(value)
+
+    @staticmethod
+    def _validate_concrete(value: pb.Value) -> None:
+        kind = value.WhichOneof("kind")
+        if kind in ("string_value", "int_value", "bool_value", "null_value"):
+            return
+        if kind == "double_value":
+            import math
+
+            if not math.isfinite(value.double_value):
+                raise ValueError("non-finite numbers are unsupported")
+            return
+        if kind == "obj_value":
+            if value.obj_value.encoding not in ("json", "rawbytes"):
+                raise ValueError(
+                    f"unsupported object encoding {value.obj_value.encoding}"
+                )
+            return
+        raise ValueError("Value has no concrete kind")

dex_python_sdk-0.1.1/dex/_async_worker_dispatcher.py

@@ -0,0 +1,139 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+from __future__ import annotations
+
+from inspect import isawaitable
+from typing import Any
+
+from dex._async_value_hydrator import AsyncValueHydrator
+from dex._invocation_context import InvocationContext, InvocationMethod
+from dex._value_mapper import ValueMapper
+from dex._worker_dispatcher import WorkerDispatcher
+from dex.dexpb import dex_pb2 as pb
+from dex.flow import RPCResult, Registry
+from dex.step import StepDecision
+from dex.wait import Wait
+
+
+class AsyncWorkerDispatcher(WorkerDispatcher):
+    def __init__(
+        self,
+        registry: Registry,
+        values: ValueMapper,
+        hydrator: AsyncValueHydrator,
+    ) -> None:
+        self._registry = registry
+        self._values = values
+        self._hydrator = hydrator  # type: ignore[assignment]
+
+    async def invoke_wait_for(  # type: ignore[override]
+        self,
+        original: pb.InvokeWaitForMethodRequest,
+    ) -> pb.InvokeWaitForMethodResponse:
+        request = await self._hydrator.wait_for_request(original)
+        flow = self._registry._flow_by_type(request.flow_type)
+        step = flow.step(request.step_type)
+        context = InvocationContext(
+            InvocationMethod.WAIT_FOR,
+            flow,
+            request.context,
+            self._values,
+            request.attributes,
+        )
+        input = self._values.decode(request.step_input, step.input_codec)
+        wait = step.step.wait_for(context, input)
+        if isawaitable(wait):
+            wait = await wait
+        if not isinstance(wait, Wait):
+            raise TypeError("wait_for must return Wait")
+        response = pb.InvokeWaitForMethodResponse(
+            upsert_attributes=list(context.attribute_writes.values()),
+            upsert_step_exe_locals=list(context.local_writes.values()),
+            record_events=context.events,
+            publish_to_channel=context.publications,
+        )
+        waiting = self._map_wait(flow, wait)
+        if waiting is not None:
+            response.waiting_condition.CopyFrom(waiting)
+        return response
+
+    async def invoke_execute(  # type: ignore[override]
+        self,
+        original: pb.InvokeExecuteMethodRequest,
+    ) -> pb.InvokeExecuteMethodResponse:
+        request = await self._hydrator.execute_request(original)
+        flow = self._registry._flow_by_type(request.flow_type)
+        step = flow.step(request.step_type)
+        condition_results = (
+            request.condition_results if request.HasField("condition_results") else None
+        )
+        context = InvocationContext(
+            InvocationMethod.EXECUTE,
+            flow,
+            request.context,
+            self._values,
+            request.attributes,
+            request.step_exe_locals,
+            condition_results,
+        )
+        input = self._values.decode(request.step_input, step.input_codec)
+        decision: Any = step.step.execute(context, input)
+        if isawaitable(decision):
+            decision = await decision
+        if not isinstance(decision, StepDecision):
+            raise TypeError("execute must return StepDecision")
+        return pb.InvokeExecuteMethodResponse(
+            step_decision=self._map_decision(flow, decision),
+            upsert_attributes=list(context.attribute_writes.values()),
+            record_events=context.events,
+            upsert_step_exe_locals=list(context.local_writes.values()),
+            publish_to_channel=context.publications,
+        )
+
+    async def invoke_rpc(  # type: ignore[override]
+        self,
+        original: pb.InvokeWorkerRPCRequest,
+    ) -> pb.InvokeWorkerRPCResponse:
+        request = await self._hydrator.rpc_request(original)
+        flow = self._registry._flow_by_type(request.flow_type)
+        rpc = flow.rpc(request.rpc_name)
+        context = InvocationContext(
+            InvocationMethod.RPC,
+            flow,
+            request.context,
+            self._values,
+            request.attributes,
+            channel_infos=dict(request.channel_infos),
+        )
+        arguments: list[object] = [context]
+        if rpc.input_codec is not None:
+            arguments.append(self._values.decode(request.input, rpc.input_codec))
+        returned: Any = rpc.method(*arguments)
+        if isawaitable(returned):
+            returned = await returned
+        response = pb.InvokeWorkerRPCResponse(
+            upsert_attributes=list(context.attribute_writes.values()),
+            record_events=context.events,
+            publish_to_channel=context.publications,
+        )
+        if isinstance(returned, RPCResult):
+            if rpc.output_codec is None:
+                raise TypeError("RPCResult requires an output type")
+            response.output.CopyFrom(
+                self._values.encode(returned.output, rpc.output_codec)
+            )
+            if returned.next_steps:
+                response.step_decision.next_steps.extend(
+                    self._map_movements(flow, returned.next_steps)
+                )
+        elif returned is None and rpc.output_codec is None:
+            response.output.CopyFrom(self._values.encode_dynamic(None))
+        else:
+            raise TypeError("RPC must return RPCResult or None")
+        return response