diff --git a/documentation/docs/call/from_outside_your_app.mdx b/documentation/docs/call/from_outside_your_app.mdx
index 7d291a510..c186bf75e 100644
--- a/documentation/docs/call/from_outside_your_app.mdx
+++ b/documentation/docs/call/from_outside_your_app.mdx
@@ -96,18 +96,27 @@ const context = new ExternalContext({
 ## Calling readers reactively
 
 Using an `ExternalContext`, you can also call `reader` methods
-_reactively_: you receive a new response every time the state
-changes. For example:
+_reactively_: you receive a new answer every time the state changes.
+Each answer is a pair of a `response` and an `aborted`: the reader's
+response, or the error it answered with (a declared error, a denied
+`authorizer()`, a state that is not constructed yet). An error does
+not end the read; Reboot keeps the subscription open and yields again
+once the state changes, so you decide whether to keep waiting, to
+`break`, or to `raise aborted`. Failed connections are retried for
+you. For example:
 
 <Tabs groupId="language">
   <TabItem value="python" label="Python" default>
 <!-- MARKDOWN-AUTO-DOCS:START
-(CODE:src=../../../reboot/demos/fig/backend/src/many_readers.py&lines=20-22) -->
+(CODE:src=../../../reboot/demos/fig/backend/src/many_readers.py&lines=20-25) -->
 <!-- The below code snippet is automatically added from ../../../reboot/demos/fig/backend/src/many_readers.py -->
 
 ```py
 fig = Fig.ref(fig_id)
-async for response in fig.reactively().get_position(context):
+async for response, aborted in fig.reactively().get_position(context):
+    if aborted is not None:
+        print(f"{fig_id}: {aborted}")
+        continue
     print(f"{fig_id}: {response}")
 ```
 
diff --git a/reboot/bdd/steps.py b/reboot/bdd/steps.py
index a00b27fee..52ca00b66 100644
--- a/reboot/bdd/steps.py
+++ b/reboot/bdd/steps.py
@@ -1146,7 +1146,7 @@ async def _eventually_has(
                     )
                 )
             try:
-                response = await asyncio.wait_for(
+                response, aborted = await asyncio.wait_for(
                     anext(responses), timeout=remaining
                 )
             except asyncio.TimeoutError:
@@ -1160,6 +1160,16 @@ async def _eventually_has(
                     )
                 ) from None
             else:
+                if aborted is not None:
+                    # The read was answered with an error, e.g., the
+                    # state is not constructed yet. The reactive read
+                    # keeps going and is answered again once the state
+                    # changes, so keep waiting for a response.
+                    last_error = AssertionError(
+                        f"the last read was answered with {aborted}"
+                    )
+                    continue
+                assert response is not None
                 try:
                     _assert_properties(response, assertions)
                 except AssertionError as error:
diff --git a/reboot/cli/commands/cloud/up.py b/reboot/cli/commands/cloud/up.py
index 0624b4b16..731a28074 100644
--- a/reboot/cli/commands/cloud/up.py
+++ b/reboot/cli/commands/cloud/up.py
@@ -222,9 +222,13 @@ async def cloud_up(args: argparse.Namespace) -> int:
             traceback.print_exc()
             terminal.fail("Please report this bug to the maintainers")
 
-    async for status_response in application.reactively().RevisionStatus(
-        context, revision_number=up_response.revision_number
-    ):
+    async for status_response, status_aborted in application.reactively(
+    ).RevisionStatus(context, revision_number=up_response.revision_number):
+        if status_aborted is not None:
+            print(f"🛑 unexpected error: {status_aborted}")
+            terminal.fail("Please report this bug to the maintainers")
+        assert status_response is not None
+
         revision = status_response.revision
         if revision.status == Status.UPPING:
             # Keep waiting.
diff --git a/reboot/demos/fig/backend/src/many_readers.py b/reboot/demos/fig/backend/src/many_readers.py
index c26583bec..96e430a2e 100644
--- a/reboot/demos/fig/backend/src/many_readers.py
+++ b/reboot/demos/fig/backend/src/many_readers.py
@@ -18,14 +18,21 @@ async def simulate_reactive_browser_reader(port: Optional[int]):
 
     async def reactively_print_fig_position(fig_id: str):
         fig = Fig.ref(fig_id)
-        async for response in fig.reactively().get_position(context):
+        async for response, aborted in fig.reactively().get_position(context):
+            if aborted is not None:
+                print(f"{fig_id}: {aborted}")
+                continue
             print(f"{fig_id}: {response}")
 
     fig_board = FigBoard.ref(FIG_BOARD_ID)
 
     fig_tasks = {}
 
-    async for response in fig_board.reactively().list(context):
+    async for response, aborted in fig_board.reactively().list(context):
+        if aborted is not None:
+            print(f"{FIG_BOARD_ID}: {aborted}")
+            continue
+        assert response is not None
 
         for fig_id in response.fig_ids:
             if fig_id not in fig_tasks:
diff --git a/reboot/plugin/skills/python/references/testing-external-context.md b/reboot/plugin/skills/python/references/testing-external-context.md
index 4c4a24ce7..51251ae40 100644
--- a/reboot/plugin/skills/python/references/testing-external-context.md
+++ b/reboot/plugin/skills/python/references/testing-external-context.md
@@ -144,14 +144,19 @@ with self.assertRaises(Aborted):
 A "another session sees the change without refreshing" story is
 tested with `reactively()`, the same push-based subscription the
 generated React hooks use. `Type.ref(id).reactively().<reader>(context)`
-returns an **async iterator** that yields a fresh response on every
-state change; `anext()` pulls the next one. Never poll in a loop
-with `asyncio.sleep` — that tests the sleep, not the reactivity.
+returns an **async iterator** that yields a `(response, aborted)`
+pair on every state change: the reader's response, or the error it
+answered with (a declared error, a denied `authorizer()`, a state
+that is not constructed yet). An error does not end the iterator; it
+yields again once the state changes. `anext()` pulls the next pair.
+Never poll in a loop with `asyncio.sleep` — that tests the sleep, not
+the reactivity.
 
 ```python
 # The "other browser session" subscribes...
 subscription = TaskList.ref(list_id).reactively().get(bob)
-first = await asyncio.wait_for(anext(subscription), timeout=10)
+first, aborted = await asyncio.wait_for(anext(subscription), timeout=10)
+self.assertIsNone(aborted)
 self.assertEqual(first.tasks, [])
 
 # ...another session writes...
@@ -159,7 +164,8 @@ await TaskList.ref(list_id).add_task(alice, title="Milk")
 
 # ...and the subscription is pushed the update.
 while True:
-    update = await asyncio.wait_for(anext(subscription), timeout=10)
+    update, aborted = await asyncio.wait_for(anext(subscription), timeout=10)
+    self.assertIsNone(aborted)
     if len(update.tasks) == 1:
         break
 self.assertEqual(update.tasks[0].title, "Milk")
diff --git a/reboot/plugin/skills/upgrade/migrations/next/reactively-yields-response-or-aborted.md b/reboot/plugin/skills/upgrade/migrations/next/reactively-yields-response-or-aborted.md
new file mode 100644
index 000000000..38e2dd97d
--- /dev/null
+++ b/reboot/plugin/skills/upgrade/migrations/next/reactively-yields-response-or-aborted.md
@@ -0,0 +1,45 @@
+## Python `reactively()` reads yield `(response, aborted)` pairs
+
+`Type.ref(id).reactively().<reader>(context)` used to yield bare
+responses and to raise the method's `<Type>.<Method>Aborted` when the
+backend answered the read with an error (a declared error raised by
+the reader, a denied `authorizer()`, `StateNotConstructed`, ...),
+which ended the read. It now yields a `(response, aborted)` pair for
+every answer and never raises: for a response, `aborted` is `None`;
+for an error, `response` is `None` and `aborted` is the method's
+`<Type>.<Method>Aborted`. An error does not end the read: the
+subscription stays open and yields again once the state changes.
+Failed connections are still retried with backoff without yielding
+anything.
+
+Find every use of such a read. Match only the opening parenthesis,
+since a formatter may have split the call across lines:
+
+    grep -rn "\.reactively(" --include=*.py
+
+Unpack the pair in every `async for` over one. Before:
+
+```python
+async for response in cart.reactively().get(context):
+    render(response)
+```
+
+After:
+
+```python
+async for response, aborted in cart.reactively().get(context):
+    if aborted is not None:
+        # Decide: `continue` to wait for the state to change, `break`
+        # to stop reading, or `raise aborted`.
+        continue
+    render(response)
+```
+
+Also:
+
+- Code that caught the `Aborted` around the loop (`try: async for ... except Type.MethodAborted:`) must handle `aborted` inside the loop
+  instead; the `except` is now unreachable.
+- Code that pulls items with `anext(...)` gets the pair too:
+  `response, aborted = await anext(subscription)`.
+- A reader whose response type is empty yields `(None, None)` on
+  success, so check `aborted`, not `response`, for those.
diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2
index 95df08592..4af2122c5 100644
--- a/reboot/templates/reboot.py.j2
+++ b/reboot/templates/reboot.py.j2
@@ -5201,7 +5201,7 @@ class {{ client.proto.state_name }}:
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: {{ client.proto.state_name }}.{{ method.proto.name }}Request,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}, None] | tuple[None, {{ client.proto.state_name }}.{{ method.proto.name }}Aborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -5219,7 +5219,7 @@ class {{ client.proto.state_name }}:
                 {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET,
                 {% endif %}
                 {% endfor %}
-            ) -> IMPORT_typing.AsyncIterator[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}, None] | tuple[None, {{ client.proto.state_name }}.{{ method.proto.name }}Aborted]]:
                 ...
             {% endif %}
 
@@ -5250,7 +5250,7 @@ class {{ client.proto.state_name }}:
                 {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET,
                 {% endif %}
                 {% endfor %}
-            ) -> IMPORT_typing.AsyncIterator[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[{% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}, None] | tuple[None, {{ client.proto.state_name }}.{{ method.proto.name }}Aborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 {% if method.has_non_none_request %}
                 # UX improvement: check that neither positional argument was accidentally
@@ -5370,7 +5370,7 @@ class {{ client.proto.state_name }}:
 
                                 __response__ = {{ method.output_type }}()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__)
+                                yield ({{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -5385,18 +5385,35 @@ class {{ client.proto.state_name }}:
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise {{ client.proto.state_name }}.{{ method.proto.name }}Aborted.from_status(
-                                    status
-                                ) from None
-                            raise {{ client.proto.state_name }}.{{ method.proto.name }}Aborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = {{ client.proto.state_name }}.{{ method.proto.name }}Aborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = {{ client.proto.state_name }}.{{ method.proto.name }}Aborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/BUILD.bazel b/tests/reboot/BUILD.bazel
index a26c3d94b..967afc7b9 100644
--- a/tests/reboot/BUILD.bazel
+++ b/tests/reboot/BUILD.bazel
@@ -384,6 +384,16 @@ py_test(
     ],
 )
 
+py_test(
+    name = "reactive_reader_tests_py",
+    srcs = [":reactive_reader_tests.py"],
+    main = "reactive_reader_tests.py",
+    deps = [
+        ":greeter_servicers_py",
+        "//reboot/aio:tests_py",
+    ],
+)
+
 py_test(
     name = "external_context_tests_py",
     srcs = [":external_context_tests.py"],
diff --git a/tests/reboot/bank.py b/tests/reboot/bank.py
index be27efaa5..bbade234f 100644
--- a/tests/reboot/bank.py
+++ b/tests/reboot/bank.py
@@ -968,7 +968,9 @@ async def test_reactive_method_call(
     ) -> Empty:
         # Call a method reactively, and see that we don't crash.
         account = Account.ref(self.state.account_ids[0])
-        async for _ in account.reactively().balance(context):
+        async for _, aborted in account.reactively().balance(context):
+            if aborted is not None:
+                raise aborted
             # Yay, that worked.
             break
 
diff --git a/tests/reboot/dashboard/api_watcher_tests.py b/tests/reboot/dashboard/api_watcher_tests.py
index 2a319ada7..68346a83f 100644
--- a/tests/reboot/dashboard/api_watcher_tests.py
+++ b/tests/reboot/dashboard/api_watcher_tests.py
@@ -122,8 +122,11 @@ async def _wait_for_api(self, satisfied):
         whenever it changes."""
         context = self.rbt.create_external_context(name=self.id())
 
-        async for response in Dashboard.ref(DASHBOARD_ID
-                                           ).reactively().Get(context):
+        async for response, aborted in Dashboard.ref(DASHBOARD_ID).reactively(
+        ).Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if satisfied(response):
                 return response
 
diff --git a/tests/reboot/dashboard/code_watcher_tests.py b/tests/reboot/dashboard/code_watcher_tests.py
index 7787c2a37..79f6c139b 100644
--- a/tests/reboot/dashboard/code_watcher_tests.py
+++ b/tests/reboot/dashboard/code_watcher_tests.py
@@ -415,8 +415,11 @@ async def _code_changes(self, *, satisfied) -> list[Change]:
         """The code's entries in the changelog once they satisfy,
         newest first, reading again whenever the changelog changes."""
         context = self.rbt.create_external_context(name=self.id())
-        async for response in OrderedMap.ref(CHANGELOG_ID).reactively(
+        async for response, aborted in OrderedMap.ref(CHANGELOG_ID).reactively(
         ).ReverseRange(context, limit=100):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             changes = [
                 Change.FromString(entry.bytes) for entry in response.entries
             ]
@@ -438,8 +441,11 @@ async def _servicers(self, *, satisfied):
         """
         context = self.rbt.create_external_context(name=self.id())
 
-        async for response in Dashboard.ref(DASHBOARD_ID
-                                           ).reactively().Get(context):
+        async for response, aborted in Dashboard.ref(DASHBOARD_ID).reactively(
+        ).Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             found: dict[str, list[Servicer]] = {}
 
             for servicer in response.servicers:
@@ -455,8 +461,11 @@ async def _implementation(self, *, satisfied):
         reading again whenever it changes."""
         context = self.rbt.create_external_context(name=self.id())
 
-        async for response in Dashboard.ref(DASHBOARD_ID
-                                           ).reactively().Get(context):
+        async for response, aborted in Dashboard.ref(DASHBOARD_ID).reactively(
+        ).Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if satisfied(response):
                 return response
 
@@ -569,8 +578,11 @@ async def test_what_is_declared_and_what_implements_it_are_separate(
 
         context = self.rbt.create_external_context(name=self.id())
 
-        async for response in Dashboard.ref(DASHBOARD_ID
-                                           ).reactively().Get(context):
+        async for response, aborted in Dashboard.ref(DASHBOARD_ID).reactively(
+        ).Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if any(
                 f'{api.package}.{state_type.name}' == 'shop.v1.Shop'
                 for api in response.apis.values()
diff --git a/tests/reboot/dashboard/dashboard_tests.py b/tests/reboot/dashboard/dashboard_tests.py
index 930e774a7..111772356 100644
--- a/tests/reboot/dashboard/dashboard_tests.py
+++ b/tests/reboot/dashboard/dashboard_tests.py
@@ -392,8 +392,12 @@ async def _wait_for_suppress_open_on_restart(self, expected: bool) -> None:
         write is what the page sends after the click, so seeing it is
         how the test knows the choice reached the application."""
         context = self.rbt.create_external_context(name=self.id())
-        async for response in Preferences.ref(PREFERENCES_ID
-                                             ).reactively().Get(context):
+        async for response, aborted in Preferences.ref(
+            PREFERENCES_ID
+        ).reactively().Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if response.suppress_open_on_restart == expected:
                 return
 
diff --git a/tests/reboot/dashboard/features_watcher_tests.py b/tests/reboot/dashboard/features_watcher_tests.py
index a0569c372..6437c151c 100644
--- a/tests/reboot/dashboard/features_watcher_tests.py
+++ b/tests/reboot/dashboard/features_watcher_tests.py
@@ -88,8 +88,11 @@ async def _wait_for_features(self, satisfied):
         again whenever they change."""
         context = self.rbt.create_external_context(name=self.id())
 
-        async for response in Dashboard.ref(DASHBOARD_ID
-                                           ).reactively().Get(context):
+        async for response, aborted in Dashboard.ref(DASHBOARD_ID).reactively(
+        ).Get(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if satisfied(response.features):
                 return response.features
 
diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py
index 9fbba8531..9243c9152 100755
--- a/tests/reboot/echo_rbt.golden.py
+++ b/tests/reboot/echo_rbt.golden.py
@@ -21157,7 +21157,7 @@ async def Replay(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Echo.ReplayRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Echo.ReplayResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.ReplayResponse, None] | tuple[None, Echo.ReplayAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -21165,7 +21165,7 @@ async def Replay(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Echo.ReplayResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.ReplayResponse, None] | tuple[None, Echo.ReplayAborted]]:
                 ...
 
             async def Replay( # type: ignore[misc]
@@ -21183,7 +21183,7 @@ async def Replay( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Echo.ReplayRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Echo.ReplayResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.ReplayResponse, None] | tuple[None, Echo.ReplayAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -21290,7 +21290,7 @@ async def Replay( # type: ignore[misc]
 
                                 __response__ = tests.reboot.echo_pb2.ReplayResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield EchoReplayResponseFromProto(__response__)
+                                yield (EchoReplayResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21305,18 +21305,35 @@ async def Replay( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Echo.ReplayAborted.from_status(
-                                    status
-                                ) from None
-                            raise Echo.ReplayAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Echo.ReplayAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Echo.ReplayAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -21328,7 +21345,7 @@ async def WaitFor(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Echo.WaitForRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Echo.WaitForResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.WaitForResponse, None] | tuple[None, Echo.WaitForAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -21338,7 +21355,7 @@ async def WaitFor(
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
                 *,
                 message: IMPORT_typing.Optional[str] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Echo.WaitForResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.WaitForResponse, None] | tuple[None, Echo.WaitForAborted]]:
                 ...
 
             async def WaitFor( # type: ignore[misc]
@@ -21358,7 +21375,7 @@ async def WaitFor( # type: ignore[misc]
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
                 *,
                 message: IMPORT_typing.Optional[str] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Echo.WaitForResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Echo.WaitForResponse, None] | tuple[None, Echo.WaitForAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -21467,7 +21484,7 @@ async def WaitFor( # type: ignore[misc]
 
                                 __response__ = tests.reboot.echo_pb2.WaitForResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield EchoWaitForResponseFromProto(__response__)
+                                yield (EchoWaitForResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21482,18 +21499,35 @@ async def WaitFor( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Echo.WaitForAborted.from_status(
-                                    status
-                                ) from None
-                            raise Echo.WaitForAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Echo.WaitForAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Echo.WaitForAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/effect_validation_tests.py b/tests/reboot/effect_validation_tests.py
index 85ea00572..78f5d7dc4 100644
--- a/tests/reboot/effect_validation_tests.py
+++ b/tests/reboot/effect_validation_tests.py
@@ -342,7 +342,9 @@ async def test_react_query(self) -> None:
         general, context = await self.create(EffectValidation.ENABLED)
 
         # Receive one message response.
-        async for response in general.reactively().Reader(context):
+        async for _, aborted in general.reactively().Reader(context):
+            if aborted is not None:
+                raise aborted
             break
         else:
             raise AssertionError("No responses returned by Query.")
diff --git a/tests/reboot/external_context_tests.py b/tests/reboot/external_context_tests.py
index dccc6e40b..93cb0098d 100644
--- a/tests/reboot/external_context_tests.py
+++ b/tests/reboot/external_context_tests.py
@@ -362,7 +362,9 @@ async def test_keepalive_and_retry_reactive_reader(self) -> None:
         async def call(
             context: ExternalContext, general: General.WeakReference
         ) -> None:
-            async for _ in general.reactively().Reader(context):
+            async for _, aborted in general.reactively().Reader(context):
+                if aborted is not None:
+                    raise aborted
                 # As soon as we receive a response, we consider the call
                 # done.
                 break
diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js
index 391cc3b83..faf1d6de2 100755
--- a/tests/reboot/greeter_rbt.golden.js
+++ b/tests/reboot/greeter_rbt.golden.js
@@ -5509,6 +5509,6 @@ Greeter._ConstructIdempotently = (_j = class {
 export function importPys() {
     reboot_native.importPy("tests.reboot.greeter_pb2", "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");
     reboot_native.importPy("tests.reboot.greeter_pb2_grpc", "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");
-    reboot_native.importPy("tests.reboot.greeter_rbt", "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");
+    reboot_native.importPy("tests.reboot.greeter_rbt", "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");
 }
 importPys();
diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py
index 49d0dc8e7..da77112d9 100755
--- a/tests/reboot/greeter_rbt.golden.py
+++ b/tests/reboot/greeter_rbt.golden.py
@@ -22075,7 +22075,7 @@ async def Greet(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.GreetRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GreetResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GreetResponse, None] | tuple[None, Greeter.GreetAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22086,7 +22086,7 @@ async def Greet(
                 *,
                 name: IMPORT_typing.Optional[str] | Unset = UNSET,
                 metadata: IMPORT_typing.Optional[dict[str, str]] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GreetResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GreetResponse, None] | tuple[None, Greeter.GreetAborted]]:
                 ...
 
             async def Greet( # type: ignore[misc]
@@ -22107,7 +22107,7 @@ async def Greet( # type: ignore[misc]
                 *,
                 name: IMPORT_typing.Optional[str] | Unset = UNSET,
                 metadata: IMPORT_typing.Optional[dict[str, str]] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GreetResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GreetResponse, None] | tuple[None, Greeter.GreetAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -22218,7 +22218,7 @@ async def Greet( # type: ignore[misc]
 
                                 __response__ = tests.reboot.greeter_pb2.GreetResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterGreetResponseFromProto(__response__)
+                                yield (GreeterGreetResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22233,18 +22233,35 @@ async def Greet( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.GreetAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.GreetAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.GreetAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.GreetAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22256,7 +22273,7 @@ async def TryToConstructContext(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.TryToConstructContextRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructContextResponse, None] | tuple[None, Greeter.TryToConstructContextAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22264,7 +22281,7 @@ async def TryToConstructContext(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructContextResponse, None] | tuple[None, Greeter.TryToConstructContextAborted]]:
                 ...
 
             async def TryToConstructContext( # type: ignore[misc]
@@ -22282,7 +22299,7 @@ async def TryToConstructContext( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.TryToConstructContextRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructContextResponse, None] | tuple[None, Greeter.TryToConstructContextAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -22389,7 +22406,7 @@ async def TryToConstructContext( # type: ignore[misc]
 
                                 __response__ = google.protobuf.empty_pb2.Empty()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTryToConstructContextResponseFromProto(__response__)
+                                yield (GreeterTryToConstructContextResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22404,18 +22421,35 @@ async def TryToConstructContext( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.TryToConstructContextAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.TryToConstructContextAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.TryToConstructContextAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.TryToConstructContextAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22427,7 +22461,7 @@ async def TryToConstructExternalContext(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.TryToConstructExternalContextRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructExternalContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructExternalContextResponse, None] | tuple[None, Greeter.TryToConstructExternalContextAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22435,7 +22469,7 @@ async def TryToConstructExternalContext(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructExternalContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructExternalContextResponse, None] | tuple[None, Greeter.TryToConstructExternalContextAborted]]:
                 ...
 
             async def TryToConstructExternalContext( # type: ignore[misc]
@@ -22453,7 +22487,7 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.TryToConstructExternalContextRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TryToConstructExternalContextResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TryToConstructExternalContextResponse, None] | tuple[None, Greeter.TryToConstructExternalContextAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -22560,7 +22594,7 @@ async def TryToConstructExternalContext( # type: ignore[misc]
 
                                 __response__ = google.protobuf.empty_pb2.Empty()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTryToConstructExternalContextResponseFromProto(__response__)
+                                yield (GreeterTryToConstructExternalContextResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22575,18 +22609,35 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.TryToConstructExternalContextAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.TryToConstructExternalContextAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.TryToConstructExternalContextAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.TryToConstructExternalContextAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22598,7 +22649,7 @@ async def TestLongRunningFetch(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.TestLongRunningFetchRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TestLongRunningFetchResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TestLongRunningFetchResponse, None] | tuple[None, Greeter.TestLongRunningFetchAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22608,7 +22659,7 @@ async def TestLongRunningFetch(
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
                 *,
                 sleep_time_seconds: IMPORT_typing.Optional[int] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TestLongRunningFetchResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TestLongRunningFetchResponse, None] | tuple[None, Greeter.TestLongRunningFetchAborted]]:
                 ...
 
             async def TestLongRunningFetch( # type: ignore[misc]
@@ -22628,7 +22679,7 @@ async def TestLongRunningFetch( # type: ignore[misc]
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
                 *,
                 sleep_time_seconds: IMPORT_typing.Optional[int] | Unset = UNSET,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.TestLongRunningFetchResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.TestLongRunningFetchResponse, None] | tuple[None, Greeter.TestLongRunningFetchAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -22737,7 +22788,7 @@ async def TestLongRunningFetch( # type: ignore[misc]
 
                                 __response__ = google.protobuf.empty_pb2.Empty()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterTestLongRunningFetchResponseFromProto(__response__)
+                                yield (GreeterTestLongRunningFetchResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22752,18 +22803,35 @@ async def TestLongRunningFetch( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.TestLongRunningFetchAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.TestLongRunningFetchAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.TestLongRunningFetchAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.TestLongRunningFetchAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22775,7 +22843,7 @@ async def GetWholeState(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.GetWholeStateRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GetWholeStateResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GetWholeStateResponse, None] | tuple[None, Greeter.GetWholeStateAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22783,7 +22851,7 @@ async def GetWholeState(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GetWholeStateResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GetWholeStateResponse, None] | tuple[None, Greeter.GetWholeStateAborted]]:
                 ...
 
             async def GetWholeState( # type: ignore[misc]
@@ -22801,7 +22869,7 @@ async def GetWholeState( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.GetWholeStateRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.GetWholeStateResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.GetWholeStateResponse, None] | tuple[None, Greeter.GetWholeStateAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -22908,7 +22976,7 @@ async def GetWholeState( # type: ignore[misc]
 
                                 __response__ = tests.reboot.greeter_pb2.Greeter()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterGetWholeStateResponseFromProto(__response__)
+                                yield (GreeterGetWholeStateResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22923,18 +22991,35 @@ async def GetWholeState( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.GetWholeStateAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.GetWholeStateAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.GetWholeStateAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.GetWholeStateAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22946,7 +23031,7 @@ async def FailWithException(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.FailWithExceptionRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithExceptionResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithExceptionResponse, None] | tuple[None, Greeter.FailWithExceptionAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -22954,7 +23039,7 @@ async def FailWithException(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithExceptionResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithExceptionResponse, None] | tuple[None, Greeter.FailWithExceptionAborted]]:
                 ...
 
             async def FailWithException( # type: ignore[misc]
@@ -22972,7 +23057,7 @@ async def FailWithException( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.FailWithExceptionRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithExceptionResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithExceptionResponse, None] | tuple[None, Greeter.FailWithExceptionAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -23079,7 +23164,7 @@ async def FailWithException( # type: ignore[misc]
 
                                 __response__ = google.protobuf.empty_pb2.Empty()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterFailWithExceptionResponseFromProto(__response__)
+                                yield (GreeterFailWithExceptionResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -23094,18 +23179,35 @@ async def FailWithException( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.FailWithExceptionAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.FailWithExceptionAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.FailWithExceptionAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.FailWithExceptionAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -23117,7 +23219,7 @@ async def FailWithAborted(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.FailWithAbortedRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithAbortedResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithAbortedResponse, None] | tuple[None, Greeter.FailWithAbortedAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -23125,7 +23227,7 @@ async def FailWithAborted(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithAbortedResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithAbortedResponse, None] | tuple[None, Greeter.FailWithAbortedAborted]]:
                 ...
 
             async def FailWithAborted( # type: ignore[misc]
@@ -23143,7 +23245,7 @@ async def FailWithAborted( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.FailWithAbortedRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.FailWithAbortedResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.FailWithAbortedResponse, None] | tuple[None, Greeter.FailWithAbortedAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -23250,7 +23352,7 @@ async def FailWithAborted( # type: ignore[misc]
 
                                 __response__ = google.protobuf.empty_pb2.Empty()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterFailWithAbortedResponseFromProto(__response__)
+                                yield (GreeterFailWithAbortedResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -23265,18 +23367,35 @@ async def FailWithAborted( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.FailWithAbortedAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.FailWithAbortedAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.FailWithAbortedAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.FailWithAbortedAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -23288,7 +23407,7 @@ async def ReadRecursiveMessage(
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: Greeter.ReadRecursiveMessageRequest,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.ReadRecursiveMessageResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.ReadRecursiveMessageResponse, None] | tuple[None, Greeter.ReadRecursiveMessageAborted]]:
                 ...
 
             @IMPORT_typing.overload
@@ -23296,7 +23415,7 @@ async def ReadRecursiveMessage(
                 __this__,
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.ReadRecursiveMessageResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.ReadRecursiveMessageResponse, None] | tuple[None, Greeter.ReadRecursiveMessageAborted]]:
                 ...
 
             async def ReadRecursiveMessage( # type: ignore[misc]
@@ -23314,7 +23433,7 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __request_or_options__: IMPORT_typing.Optional[Greeter.ReadRecursiveMessageRequest | IMPORT_reboot_aio_call.Options] = None,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Greeter.ReadRecursiveMessageResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Greeter.ReadRecursiveMessageResponse, None] | tuple[None, Greeter.ReadRecursiveMessageAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 # UX improvement: check that neither positional argument was accidentally
                 # given a gRPC request type.
@@ -23421,7 +23540,7 @@ async def ReadRecursiveMessage( # type: ignore[misc]
 
                                 __response__ = tests.reboot.greeter_pb2.ReadRecursiveMessageResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield GreeterReadRecursiveMessageResponseFromProto(__response__)
+                                yield (GreeterReadRecursiveMessageResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -23436,18 +23555,35 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Greeter.ReadRecursiveMessageAborted.from_status(
-                                    status
-                                ) from None
-                            raise Greeter.ReadRecursiveMessageAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Greeter.ReadRecursiveMessageAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Greeter.ReadRecursiveMessageAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py
index 2896c6b2b..7f8d985c5 100755
--- a/tests/reboot/ping_api_rbt.golden.py
+++ b/tests/reboot/ping_api_rbt.golden.py
@@ -21718,7 +21718,7 @@ async def Describe( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Ping.DescribeResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Ping.DescribeResponse, None] | tuple[None, Ping.DescribeAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -21806,7 +21806,7 @@ async def Describe( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.PingDescribeResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield PingDescribeResponseFromProto(__response__)
+                                yield (PingDescribeResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21821,18 +21821,35 @@ async def Describe( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Ping.DescribeAborted.from_status(
-                                    status
-                                ) from None
-                            raise Ping.DescribeAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Ping.DescribeAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Ping.DescribeAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -21853,7 +21870,7 @@ async def NumPings( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Ping.NumPingsResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Ping.NumPingsResponse, None] | tuple[None, Ping.NumPingsAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -21941,7 +21958,7 @@ async def NumPings( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.PingNumPingsResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield PingNumPingsResponseFromProto(__response__)
+                                yield (PingNumPingsResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21956,18 +21973,35 @@ async def NumPings( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Ping.NumPingsAborted.from_status(
-                                    status
-                                ) from None
-                            raise Ping.NumPingsAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Ping.NumPingsAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Ping.NumPingsAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -24503,7 +24537,7 @@ async def NumPongs( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Pong.NumPongsResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Pong.NumPongsResponse, None] | tuple[None, Pong.NumPongsAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -24591,7 +24625,7 @@ async def NumPongs( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.PongNumPongsResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield PongNumPongsResponseFromProto(__response__)
+                                yield (PongNumPongsResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -24606,18 +24640,35 @@ async def NumPongs( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Pong.NumPongsAborted.from_status(
-                                    status
-                                ) from None
-                            raise Pong.NumPongsAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Pong.NumPongsAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Pong.NumPongsAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -27239,7 +27290,7 @@ async def ListCounters( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[User.ListCountersResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[User.ListCountersResponse, None] | tuple[None, User.ListCountersAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -27327,7 +27378,7 @@ async def ListCounters( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.UserListCountersResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield UserListCountersResponseFromProto(__response__)
+                                yield (UserListCountersResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -27342,18 +27393,35 @@ async def ListCounters( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise User.ListCountersAborted.from_status(
-                                    status
-                                ) from None
-                            raise User.ListCountersAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = User.ListCountersAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = User.ListCountersAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -27374,7 +27442,7 @@ async def Whoami( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[User.WhoamiResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[User.WhoamiResponse, None] | tuple[None, User.WhoamiAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -27462,7 +27530,7 @@ async def Whoami( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.UserWhoamiResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield UserWhoamiResponseFromProto(__response__)
+                                yield (UserWhoamiResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -27477,18 +27545,35 @@ async def Whoami( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise User.WhoamiAborted.from_status(
-                                    status
-                                ) from None
-                            raise User.WhoamiAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = User.WhoamiAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = User.WhoamiAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -31019,7 +31104,7 @@ async def Value( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Counter.ValueResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Counter.ValueResponse, None] | tuple[None, Counter.ValueAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -31107,7 +31192,7 @@ async def Value( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.CounterValueResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield CounterValueResponseFromProto(__response__)
+                                yield (CounterValueResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -31122,18 +31207,35 @@ async def Value( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Counter.ValueAborted.from_status(
-                                    status
-                                ) from None
-                            raise Counter.ValueAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Counter.ValueAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Counter.ValueAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -31154,7 +31256,7 @@ async def Description( # type: ignore[misc]
                 # (B) methods that may reasonably run for a long time, which in Reboot means: readers or workflows.
                 __context__: IMPORT_reboot_aio_external.ExternalContext | IMPORT_reboot_aio_contexts.ReaderContext | IMPORT_reboot_aio_contexts.WorkflowContext,
                 __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None,
-            ) -> IMPORT_typing.AsyncIterator[Counter.DescriptionResponse]:
+            ) -> IMPORT_typing.AsyncIterator[tuple[Counter.DescriptionResponse, None] | tuple[None, Counter.DescriptionAborted]]:
                 IMPORT_reboot_aio_types.assert_type(__context__, [IMPORT_reboot_aio_external.ExternalContext, IMPORT_reboot_aio_contexts.ReaderContext, IMPORT_reboot_aio_contexts.WorkflowContext])
                 assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options)
 
@@ -31242,7 +31344,7 @@ async def Description( # type: ignore[misc]
 
                                 __response__ = reboot.ping.ping_api_pb2.CounterDescriptionResponse()
                                 __response__.ParseFromString(__query_response__.response)
-                                yield CounterDescriptionResponseFromProto(__response__)
+                                yield (CounterDescriptionResponseFromProto(__response__), None)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -31257,18 +31359,35 @@ async def Description( # type: ignore[misc]
                             )
                             await __query_backoff__()
                             continue
-                        if error.code() == IMPORT_grpc.StatusCode.ABORTED:
-                            # Reconstitute the error that the server threw, if it was a declared error.
-                            status = await IMPORT_rpc_status_async.from_call(__call__)
-                            if status is not None:
-                                raise Counter.DescriptionAborted.from_status(
-                                    status
-                                ) from None
-                            raise Counter.DescriptionAborted.from_grpc_aio_rpc_error(
+
+                        # The server answered the read with an error,
+                        # e.g., a declared error raised by the reader, a
+                        # denied authorizer, or a state that has not been
+                        # constructed (yet). That answer is a value to
+                        # the caller, not the end of the read: the state
+                        # may change so that the next read succeeds, so
+                        # we keep reading, and it is up to the caller to
+                        # stop iterating (or to raise) if the error is
+                        # final for them.
+                        #
+                        # Reconstitute the error that the server threw,
+                        # if it was a declared error.
+                        status = (
+                            await IMPORT_rpc_status_async.from_call(__call__)
+                            if __call__ is not None else None
+                        )
+                        if status is not None:
+                            __aborted__ = Counter.DescriptionAborted.from_status(
+                                status
+                            )
+                        else:
+                            __aborted__ = Counter.DescriptionAborted.from_grpc_aio_rpc_error(
                                 error
-                            ) from None
+                            )
 
-                        raise
+                        yield (None, __aborted__)
+
+                        await __query_backoff__()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/react/std/presence/test.py b/tests/reboot/react/std/presence/test.py
index 9273b15d9..aad0c8c3b 100644
--- a/tests/reboot/react/std/presence/test.py
+++ b/tests/reboot/react/std/presence/test.py
@@ -45,10 +45,17 @@ def run_selenium_test():
     await asyncio.to_thread(run_selenium_test)
 
     # Test that subscriber is not present after disconnect.
-    async for response in SUBSCRIBER_REF.reactively().Status(context):
+    async for response, aborted in SUBSCRIBER_REF.reactively(
+    ).Status(context):
+        if aborted is not None:
+            raise aborted
+        assert response is not None
         if not response.present:
             break
 
-    async for response in PRESENCE_REF.reactively().List(context):
+    async for response, aborted in PRESENCE_REF.reactively().List(context):
+        if aborted is not None:
+            raise aborted
+        assert response is not None
         if response.subscriber_ids == []:
             break
diff --git a/tests/reboot/reactive_reader_tests.py b/tests/reboot/reactive_reader_tests.py
new file mode 100644
index 000000000..51f67cbc3
--- /dev/null
+++ b/tests/reboot/reactive_reader_tests.py
@@ -0,0 +1,94 @@
+import asyncio
+import unittest
+from rbt.v1alpha1.errors_pb2 import StateNotConstructed
+from reboot.aio.applications import Application
+from reboot.aio.tests import Reboot
+from tests.reboot.greeter_rbt import ErrorWithValue, Greeter
+from tests.reboot.greeter_servicers import MyGreeterServicer
+
+# A reactive read is a live stream of answers: a response, or the
+# error the reader answered with. An error is a value in that stream,
+# not the end of it; the read keeps going and is answered again once
+# the state changes.
+
+
+class ReactiveReaderTest(unittest.IsolatedAsyncioTestCase):
+
+    async def asyncSetUp(self) -> None:
+        self.rbt = Reboot()
+        await self.rbt.start()
+        await self.rbt.up(Application(servicers=[MyGreeterServicer]))
+
+    async def asyncTearDown(self) -> None:
+        await self.rbt.stop()
+
+    async def test_state_not_constructed_then_response(self) -> None:
+        """A read of a state that is not constructed yet is answered
+        with `StateNotConstructed`, and with a response once the state
+        is constructed by someone else."""
+        context = self.rbt.create_external_context(name=self.id())
+
+        responses = Greeter.ref('greeter').reactively().Greet(context)
+
+        response, aborted = await asyncio.wait_for(
+            anext(responses), timeout=10
+        )
+        self.assertIsNone(response)
+        assert aborted is not None
+        self.assertIsInstance(aborted.error, StateNotConstructed)
+
+        # Construct the state from another context, as another client
+        # would.
+        await Greeter.Create(
+            self.rbt.create_external_context(name=f'{self.id()}-other'),
+            'greeter',
+            title='Dr',
+            name='Jonathan',
+            adjective='best',
+        )
+
+        # The read is still open: it may be answered with
+        # `StateNotConstructed` a few more times until the construction
+        # is observed, and then with a response.
+        while True:
+            response, aborted = await asyncio.wait_for(
+                anext(responses), timeout=30
+            )
+            if response is not None:
+                break
+            assert aborted is not None
+            self.assertIsInstance(aborted.error, StateNotConstructed)
+
+        self.assertIsNone(aborted)
+        self.assertEqual(response.message, 'Hi ??, I am Dr Jonathan the best')
+
+        await responses.aclose()
+
+    async def test_declared_error_is_yielded_and_read_again(self) -> None:
+        """A declared error raised by the reader is yielded, more than
+        once: it does not end the read."""
+        context = self.rbt.create_external_context(name=self.id())
+
+        greeter, _ = await Greeter.Create(
+            context,
+            title='Dr',
+            name='Jonathan',
+            adjective='best',
+        )
+
+        responses = greeter.reactively().FailWithAborted(context)
+
+        for _ in range(2):
+            response, aborted = await asyncio.wait_for(
+                anext(responses), timeout=30
+            )
+            self.assertIsNone(response)
+            assert aborted is not None
+            self.assertIsInstance(aborted.error, ErrorWithValue)
+            self.assertEqual(aborted.error.value, 'Hi!')
+
+        await responses.aclose()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index 488b1cf11..63b2feade 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -28,8 +28,11 @@ async def start_accumulating_adjectives(
     ):
 
         async def _do():
-            async for greeter_state in greeter.reactively(
+            async for greeter_state, aborted in greeter.reactively(
             ).GetWholeState(context):
+                if aborted is not None:
+                    raise aborted
+                assert greeter_state is not None
                 self._accumulated_adjectives.append(greeter_state.adjective)
                 self._accumulated_adjective.set()
 
diff --git a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py
index e012fd02c..60661b8dd 100644
--- a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py
+++ b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py
@@ -88,9 +88,12 @@ async def _wait_for_active_version(self, version: int) -> None:
         # The `Watch` control loop rotates in the background; react to
         # `status` updates until the active version reaches the expected
         # one and the rotation has settled (the test times out otherwise).
-        async for response in KeyManager.ref(
+        async for response, aborted in KeyManager.ref(
             APP_SHARED_KEY_MANAGER_ID,
         ).reactively().status(self.context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if response.active_version >= version and not response.rotating:
                 break
 
diff --git a/tests/reboot/std/collections/sorted_map_tests.py b/tests/reboot/std/collections/sorted_map_tests.py
index 613c89bd9..c2190d1f9 100644
--- a/tests/reboot/std/collections/sorted_map_tests.py
+++ b/tests/reboot/std/collections/sorted_map_tests.py
@@ -236,9 +236,11 @@ async def test_basic(self) -> None:
         self.assertFalse(get_response.HasField('value'))
 
         # Test `reactively().range`.
-        async for range_response in sorted_map.reactively().range(
+        async for range_response, aborted in sorted_map.reactively().range(
             context, limit=1
         ):
+            self.assertIsNone(aborted)
+            assert range_response is not None
             self.assert_range_response(full, range_response)
             break
         else:
@@ -292,16 +294,16 @@ async def test_limit_zero(self) -> None:
         self.assertIn(
             "Range requires a non-zero `limit` value.", str(aborted.exception)
         )
-        # The same error should also appear when using the reactive API.
-        with self.assertRaises(SortedMap.RangeAborted) as aborted:
-            async for range_response in sorted_map.reactively().range(
-                context,
-                limit=0,
-            ):
-                break
-        self.assertEqual(type(aborted.exception.error), InvalidRangeError)
+        # The same error should also appear when using the reactive API,
+        # which yields it (and keeps reading) rather than raising it.
+        responses = sorted_map.reactively().range(context, limit=0)
+        range_response, reactive_aborted = await anext(responses)
+        await responses.aclose()
+        self.assertIsNone(range_response)
+        assert reactive_aborted is not None
+        self.assertEqual(type(reactive_aborted.error), InvalidRangeError)
         self.assertIn(
-            "Range requires a non-zero `limit` value.", str(aborted.exception)
+            "Range requires a non-zero `limit` value.", str(reactive_aborted)
         )
 
     async def test_limit_zero_reverse(self) -> None:
diff --git a/tests/reboot/std/presence/presence_tests.py b/tests/reboot/std/presence/presence_tests.py
index 8164adf16..0b0551c3b 100644
--- a/tests/reboot/std/presence/presence_tests.py
+++ b/tests/reboot/std/presence/presence_tests.py
@@ -220,14 +220,21 @@ async def test_single_subscriber(self) -> None:
         # update things based on the cancelled connection. We use reactively
         # to do so, and let the test timeout if we never get the response we
         # are expecting.
-        async for response in subscriber.reactively().Status(context):
+        async for response, aborted in subscriber.reactively(
+        ).Status(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if not response.present:
                 break
 
-        async for response in presence.reactively().List(context):
+        async for response, aborted in presence.reactively().List(context):
+            if aborted is not None:
+                raise aborted
+            assert response is not None
             if response.subscriber_ids == []:
                 break
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()