Address review: settle registration on reconnect exhaustion; null-safe reply

- All three clients reject the registration waiter when reconnects are exhausted
  before registering, so serve()/whenRegistered() no longer hang forever.
- TS onRegistered tolerates a null/undefined reply data (treats it as an invalid
  reply hard-fail) instead of throwing a TypeError that misroutes to reconnect.
- Guard the Python reconnect tests against a race reading the re-register frame.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: willwashburn

packages/sdk-python/src/relay_sdk/node.py

@@ -421,9 +421,13 @@ async def _reader_loop(self, conn: NodeConnection) -> None:
 
     async def _backoff_sleep(self) -> None:
         if self._max_reconnect_attempts is not None and self._reconnect_attempt >= self._max_reconnect_attempts:
-            self._report_error(NodeProviderError("node provider exhausted reconnect attempts"))
+            err = NodeProviderError("node provider exhausted reconnect attempts")
+            self._report_error(err)
+            # If registration never completed, reject its waiter too — otherwise
+            # wait_registered() would hang forever after reconnects are exhausted.
+            self._reject_registered(err)
             self._stopped = True
-            return
+            raise err
         self._reconnect_attempt += 1
         exp = min(self._reconnect_base_delay * (2 ** (self._reconnect_attempt - 1)), self._reconnect_max_delay)
         delay = exp * (0.5 + random.random()) if self._reconnect_jitter else exp

packages/sdk-python/tests/test_node.py

@@ -357,6 +357,7 @@ async def test_reconnects_with_new_instance_id_after_unexpected_drop():
     first.drop()
     second = await server.next_connection()
     assert second is not first
+    await wait_until(lambda: len(second.sent_of_type("node.register")) >= 1)
     second_register = second.last_register()
     assert second_register["name"] == "alpha"
     assert second_register["provider"]["name"] == "py"
@@ -384,6 +385,7 @@ async def test_reconnects_when_dropped_during_register_handshake():
 
     second = await server.next_connection()
     assert second is not first
+    await wait_until(lambda: len(second.sent_of_type("node.register")) >= 1)
     second.push(accept_all(second.last_register()))
     await asyncio.wait_for(node.wait_registered(), timeout=1.0)
     assert node.connected is True

packages/sdk-swift/Sources/Relaycast/NodeProvider.swift

@@ -434,6 +434,10 @@ public actor NodeProvider {
                     let error = NodeProviderError.reconnectAttemptsExhausted
                     stopped = true
                     reportError(error)
+                    // If registration never completed, fail its waiter too —
+                    // otherwise waitRegistered() would hang forever after
+                    // reconnects are exhausted.
+                    settleRegistration(.failure(error))
                     throw error
                 }
                 reconnectAttempt += 1

packages/sdk-typescript/src/__tests__/node-provider.test.ts

@@ -279,6 +279,20 @@ describe('NodeProviderClient', () => {
     expect(node.connected).toBe(true);
   });
 
+  it('rejects whenRegistered when reconnects are exhausted before registering', async () => {
+    const node = new NodeProviderClient({ ...baseOptions, maxReconnectAttempts: 1 });
+    node.serve().catch(() => {});
+    const first = newSocket();
+    first.open();
+    first.drop(); // dropped mid-handshake -> reconnect
+    await vi.advanceTimersByTimeAsync(50);
+    const second = newSocket();
+    second.open();
+    second.drop(); // second attempt drops -> reconnects exhausted
+    await vi.advanceTimersByTimeAsync(50);
+    await expect(node.whenRegistered()).rejects.toThrow(/exhausted/i);
+  });
+
   it('deregisters the provider on graceful stop', async () => {
     const node = new NodeProviderClient(baseOptions);
     node.serve();

packages/sdk-typescript/src/node-provider.ts

@@ -351,10 +351,10 @@ export class NodeProviderClient {
 
   private onRegistered(data: NodeRegisterReplyData): void {
     // The reply must carry a well-formed acceptance list (the engine always
-    // does). A missing/corrupt list means acceptance can't be confirmed, so
-    // fail registration rather than assume success; an entry missing `accepted`
-    // counts as rejected (fail-safe).
-    const list = data.accepted_capabilities;
+    // does). A missing/corrupt reply (including a null `data`) means acceptance
+    // can't be confirmed, so fail registration rather than assume success or
+    // throw; an entry missing `accepted` counts as rejected (fail-safe).
+    const list = (data ?? ({} as NodeRegisterReplyData)).accepted_capabilities;
     if (!Array.isArray(list)) {
       this.onRegisterFailed(new NodeRegistrationError(
         'Registration reply is missing accepted_capabilities',
@@ -546,6 +546,11 @@ export class NodeProviderClient {
       const err = new Error('node provider exhausted reconnect attempts');
       this.reportError(err);
       this.stopped = true;
+      // If registration never completed, reject its waiter too — otherwise
+      // whenRegistered() would hang forever after reconnects are exhausted.
+      this.rejectRegister?.(err);
+      this.rejectRegister = null;
+      this.resolveRegister = null;
       this.settleServe(err);
       return;
     }