starpc 0.51.0 → 0.52.1

package/dist/srpc/watchdog.test.js

@@ -5,6 +5,7 @@ describe('Watchdog', () => {
         vi.useFakeTimers();
     });
     afterEach(() => {
+        vi.useRealTimers();
         vi.restoreAllMocks();
     });
     it('should call expired callback after timeout', () => {

package/dist/testdata/packet-codec-vectors.json

@@ -0,0 +1,64 @@
+{
+    "version": 1,
+    "max_message_size": 10000000,
+    "frame_prefix": "uint32 little-endian",
+    "cases": [
+        {
+            "name": "call_start_data",
+            "packet_hex": "0a120a0373766312066d6574686f641a03616263",
+            "frame_hex": "140000000a120a0373766312066d6574686f641a03616263"
+        },
+        {
+            "name": "call_start_absent_empty",
+            "packet_hex": "0a0d0a0373766312066d6574686f64",
+            "frame_hex": "0f0000000a0d0a0373766312066d6574686f64"
+        },
+        {
+            "name": "call_start_present_empty",
+            "packet_hex": "0a0f0a0373766312066d6574686f642001",
+            "frame_hex": "110000000a0f0a0373766312066d6574686f642001"
+        },
+        {
+            "name": "call_data_terminal",
+            "packet_hex": "12070a036f75741801",
+            "frame_hex": "0900000012070a036f75741801"
+        },
+        {
+            "name": "call_data_error",
+            "packet_hex": "120a180122066661696c6564",
+            "frame_hex": "0c000000120a180122066661696c6564"
+        },
+        {
+            "name": "call_cancel",
+            "packet_hex": "1801",
+            "frame_hex": "020000001801"
+        },
+        {
+            "name": "malformed_complete",
+            "frame_hex": "030000000a01ff",
+            "expect_error": "malformed_packet"
+        },
+        {
+            "name": "invalid_zero_length",
+            "frame_hex": "00000000",
+            "expect_error": "invalid_length"
+        },
+        {
+            "name": "invalid_oversized_prefix",
+            "frame_hex": "81969800",
+            "expect_error": "oversized_frame"
+        },
+        {
+            "name": "invalid_empty_packet",
+            "packet_hex": "",
+            "expect_error": "empty_packet"
+        },
+        { "name": "invalid_empty_service_id", "expect_error": "empty_service_id" },
+        { "name": "invalid_empty_method_id", "expect_error": "empty_method_id" },
+        {
+            "name": "truncated_body",
+            "frame_hex": "040000000a01",
+            "expect_error": "truncated_frame"
+        }
+    ]
+}

package/echo/client-test.ts

@@ -2,7 +2,10 @@ import { Client, ERR_RPC_ABORT } from '../srpc/index.js'
 import { EchoMsg } from './echo.pb.js'
 import { EchoerClient } from './echo_srpc.pb.js'
 import { pushable } from 'it-pushable'
-import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js'
+import {
+  buildRpcStreamOpenStream,
+  openRpcStream,
+} from '../rpcstream/rpcstream.js'
 import { Message } from '@aptre/protobuf-es-lite'
 
 export async function runClientTest(client: Client) {
@@ -89,8 +92,19 @@ export async function runAbortControllerTest(client: Client) {
   })
 }
 
+function requireError(
+  error: unknown,
+  label: string,
+  fragments: string[],
+): void {
+  const message = error instanceof Error ? error.message : String(error)
+  if (!fragments.some((fragment) => message.includes(fragment))) {
+    throw new Error(`${label} returned unexpected error: ${message}`)
+  }
+}
+
 // runRpcStreamTest tests a RPCStream.
-export async function runRpcStreamTest(client: Client) {
+export async function runRpcStreamTest(client: Client, release = false) {
   console.log('Calling RpcStream to open a RPC stream client...')
   const service = new EchoerClient(client)
   const openStreamFn = buildRpcStreamOpenStream(
@@ -106,4 +120,112 @@ export async function runRpcStreamTest(client: Client) {
 
   console.log('Running client test over RPC stream...')
   await runClientTest(proxiedClient)
+
+  if (release) {
+    let unknownRejected = false
+    try {
+      await openRpcStream('missing', service.RpcStream.bind(service), true)
+    } catch (error) {
+      unknownRejected = true
+      requireError(error, 'unknown component', ['unknown component: missing'])
+    }
+    if (!unknownRejected) {
+      throw new Error('unknown component unexpectedly succeeded')
+    }
+  }
+
+  let methodRejected = false
+  try {
+    await proxiedClient.request('missing.Service', 'Missing', new Uint8Array())
+  } catch (error) {
+    methodRejected = true
+    requireError(error, 'unknown nested method', [
+      'missing.Service',
+      'unimplemented',
+    ])
+  }
+  if (!methodRejected) {
+    throw new Error('unknown nested method unexpectedly succeeded')
+  }
+
+  if (release) {
+    const terminalService = new EchoerClient(proxiedClient)
+    let terminalFailed = false
+    try {
+      await terminalService.Echo({ body: '__nested_error__' })
+    } catch (error) {
+      terminalFailed = true
+      requireError(error, 'terminal nested error', ['nested terminal error'])
+    }
+    if (!terminalFailed) {
+      throw new Error('terminal nested error unexpectedly succeeded')
+    }
+  }
+
+  if (release) {
+    const releaseClient = new Client(
+      buildRpcStreamOpenStream('release', service.RpcStream.bind(service)),
+    )
+    let releaseFailed = false
+    const releaseService = new EchoerClient(releaseClient)
+    try {
+      await releaseService.Echo({ body: '__nested_release__' })
+    } catch (error) {
+      releaseFailed = true
+      requireError(error, 'release during active call', [
+        'closed before completion',
+        'stream closed',
+        'abort',
+        'cancel',
+      ])
+    }
+    if (!releaseFailed) {
+      throw new Error('release during active call unexpectedly succeeded')
+    }
+    const releaseStatus = await service.Echo({
+      body: '__nested_release_status__',
+    })
+    if (releaseStatus.body !== 'released') {
+      throw new Error(`release completion returned ${releaseStatus.body}`)
+    }
+    let releasedRejected = false
+    try {
+      await releaseService.Echo({})
+    } catch (error) {
+      releasedRejected = true
+      requireError(error, 'released component', ['unknown component: release'])
+    }
+    if (!releasedRejected) {
+      throw new Error('released component unexpectedly remained available')
+    }
+  }
+
+  const cancelled = new AbortController()
+  const cancelledStream = proxiedClient.bidirectionalStreamingRequest(
+    'echo.Echoer',
+    'EchoBidiStream',
+    (async function* () {
+      yield new Uint8Array()
+      await new Promise(() => undefined)
+    })(),
+    cancelled.signal,
+  )
+  const cancelledIterator = cancelledStream[Symbol.asyncIterator]()
+  const firstNestedResponse = await cancelledIterator.next()
+  if (firstNestedResponse.done) {
+    throw new Error('nested cancellation call ended before its first response')
+  }
+  cancelled.abort()
+  let cancelRejected = false
+  try {
+    while (!(await cancelledIterator.next()).done) {
+      // Drain until the abort reaches the nested call.
+    }
+  } catch (error) {
+    cancelRejected = true
+    requireError(error, 'nested cancellation', [ERR_RPC_ABORT])
+  }
+  if (!cancelRejected) {
+    throw new Error('nested cancellation unexpectedly completed normally')
+  }
 }

package/echo/echo_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: github.com/aperturerobotics/starpc/echo/echo.proto
+# Protobuf Python Version: 6.33.4
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    33,
+    4,
+    '',
+    'github.com/aperturerobotics/starpc/echo/echo.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from rpcstream import rpcstream_pb2 as github_dot_com_dot_aperturerobotics_dot_starpc_dot_rpcstream_dot_rpcstream__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n2github.com/aperturerobotics/starpc/echo/echo.proto\x12\x04\x65\x63ho\x1a<github.com/aperturerobotics/starpc/rpcstream/rpcstream.proto\x1a\x1bgoogle/protobuf/empty.proto\"\x17\n\x07\x45\x63hoMsg\x12\x0c\n\x04\x62ody\x18\x01 \x01(\t2\xd0\x02\n\x06\x45\x63hoer\x12$\n\x04\x45\x63ho\x12\r.echo.EchoMsg\x1a\r.echo.EchoMsg\x12\x32\n\x10\x45\x63hoServerStream\x12\r.echo.EchoMsg\x1a\r.echo.EchoMsg0\x01\x12\x32\n\x10\x45\x63hoClientStream\x12\r.echo.EchoMsg\x1a\r.echo.EchoMsg(\x01\x12\x32\n\x0e\x45\x63hoBidiStream\x12\r.echo.EchoMsg\x1a\r.echo.EchoMsg(\x01\x30\x01\x12G\n\tRpcStream\x12\x1a.rpcstream.RpcStreamPacket\x1a\x1a.rpcstream.RpcStreamPacket(\x01\x30\x01\x12;\n\tDoNothing\x12\x16.google.protobuf.Empty\x1a\x16.google.protobuf.Emptyb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'github.com.aperturerobotics.starpc.echo.echo_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ECHOMSG']._serialized_start=151
+  _globals['_ECHOMSG']._serialized_end=174
+  _globals['_ECHOER']._serialized_start=177
+  _globals['_ECHOER']._serialized_end=513
+# @@protoc_insertion_point(module_scope)

package/echo/echo_pb2.pyi

@@ -0,0 +1,13 @@
+from rpcstream import rpcstream_pb2 as _rpcstream_pb2
+from google.protobuf import empty_pb2 as _empty_pb2
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class EchoMsg(_message.Message):
+    __slots__ = ("body",)
+    BODY_FIELD_NUMBER: _ClassVar[int]
+    body: str
+    def __init__(self, body: _Optional[str] = ...) -> None: ...

package/echo/echo_srpc.pb.ts

@@ -11,6 +11,7 @@ import {
   buildEncodeMessageTransform,
   MessageStream,
   ProtoRpc,
+  ServerContext,
 } from 'starpc'
 
 /**
@@ -151,6 +152,79 @@ export interface Echoer {
   DoNothing(request: Empty, abortSignal?: AbortSignal): Promise<Empty>
 }
 
+/**
+ * Echoer service returns the given message.
+ *
+ * @generated from service echo.Echoer
+ */
+export interface EchoerHandler {
+  /**
+   * Echo returns the given message.
+   *
+   * @generated from rpc echo.Echoer.Echo
+   */
+  Echo(
+    request: EchoMsg,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): Promise<EchoMsg>
+
+  /**
+   * EchoServerStream is an example of a server -> client one-way stream.
+   *
+   * @generated from rpc echo.Echoer.EchoServerStream
+   */
+  EchoServerStream(
+    request: EchoMsg,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): MessageStream<EchoMsg>
+
+  /**
+   * EchoClientStream is an example of client->server one-way stream.
+   *
+   * @generated from rpc echo.Echoer.EchoClientStream
+   */
+  EchoClientStream(
+    request: MessageStream<EchoMsg>,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): Promise<EchoMsg>
+
+  /**
+   * EchoBidiStream is an example of a two-way stream.
+   *
+   * @generated from rpc echo.Echoer.EchoBidiStream
+   */
+  EchoBidiStream(
+    request: MessageStream<EchoMsg>,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): MessageStream<EchoMsg>
+
+  /**
+   * RpcStream opens a nested rpc call stream.
+   *
+   * @generated from rpc echo.Echoer.RpcStream
+   */
+  RpcStream(
+    request: MessageStream<RpcStreamPacket>,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): MessageStream<RpcStreamPacket>
+
+  /**
+   * DoNothing does nothing.
+   *
+   * @generated from rpc echo.Echoer.DoNothing
+   */
+  DoNothing(
+    request: Empty,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): Promise<Empty>
+}
+
 export const EchoerServiceName = EchoerDefinition.typeName
 
 export class EchoerClient implements Echoer {

package/echo/echo_srpc.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, AsyncIterator
+from typing import Protocol
+
+from google.protobuf import empty_pb2 as _google_protobuf_empty_pb2
+
+from echo import (
+    echo_pb2 as _github_com_aperturerobotics_starpc_echo_echo_pb2,
+)
+from rpcstream import (
+    rpcstream_pb2 as _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2,
+)
+from starpc.call import Call, CallProtocolError
+from starpc.client import Client
+from starpc.server import ServiceRegistry
+from starpc.service import MethodDescriptor, ServiceDescriptor, bidirectional_bytes
+
+ECHOER_SERVICE = ServiceDescriptor(
+    "echo.Echoer",
+    (
+        MethodDescriptor(
+            "Echo",
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            False,
+            False,
+        ),
+        MethodDescriptor(
+            "EchoServerStream",
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            False,
+            True,
+        ),
+        MethodDescriptor(
+            "EchoClientStream",
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            True,
+            False,
+        ),
+        MethodDescriptor(
+            "EchoBidiStream",
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg,
+            True,
+            True,
+        ),
+        MethodDescriptor(
+            "RpcStream",
+            _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket,
+            _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket,
+            True,
+            True,
+        ),
+        MethodDescriptor(
+            "DoNothing",
+            _google_protobuf_empty_pb2.Empty,
+            _google_protobuf_empty_pb2.Empty,
+            False,
+            False,
+        ),
+    ),
+)
+
+
+class EchoerClient:
+    def __init__(self, client: Client, service: str | None = None) -> None:
+        self._client = client
+        self._service = service or "echo.Echoer"
+
+    async def echo(
+        self, request: _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+    ) -> _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg:
+        call = await self._client.open_call(
+            self._service, "Echo", request.SerializeToString(deterministic=True)
+        )
+        try:
+            data = await call.receive()
+            if data is None:
+                raise CallProtocolError("missing unary response")
+            response = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+            response.ParseFromString(data)
+            if await call.receive() is not None:
+                raise CallProtocolError("extra unary response")
+            return response
+        finally:
+            await call.aclose()
+
+    async def echo_server_stream(
+        self, request: _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+    ) -> AsyncIterator[_github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg]:
+        call = await self._client.open_call(
+            self._service,
+            "EchoServerStream",
+            request.SerializeToString(deterministic=True),
+        )
+        try:
+            while True:
+                data = await call.receive()
+                if data is None:
+                    return
+                response = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+                response.ParseFromString(data)
+                yield response
+        finally:
+            await call.aclose()
+
+    async def echo_client_stream(
+        self,
+        requests: AsyncIterable[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ],
+    ) -> _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg:
+        call = await self._client.open_call(self._service, "EchoClientStream")
+        try:
+            async for request in requests:
+                await call.send(request.SerializeToString(deterministic=True))
+            await call.finish()
+            data = await call.receive()
+            if data is None:
+                raise CallProtocolError("missing client-stream response")
+            response = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+            response.ParseFromString(data)
+            if await call.receive() is not None:
+                raise CallProtocolError("extra client-stream response")
+            return response
+        finally:
+            await call.aclose()
+
+    async def echo_bidi_stream(
+        self,
+        requests: AsyncIterable[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ],
+    ) -> AsyncIterator[_github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg]:
+        call = await self._client.open_call(self._service, "EchoBidiStream")
+
+        async def encoded() -> AsyncIterator[bytes]:
+            async for request in requests:
+                yield request.SerializeToString(deterministic=True)
+
+        async for data in bidirectional_bytes(call, encoded()):
+            response = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+            response.ParseFromString(data)
+            yield response
+
+    async def rpc_stream(
+        self,
+        requests: AsyncIterable[
+            _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket
+        ],
+    ) -> AsyncIterator[
+        _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket
+    ]:
+        call = await self._client.open_call(self._service, "RpcStream")
+
+        async def encoded() -> AsyncIterator[bytes]:
+            async for request in requests:
+                yield request.SerializeToString(deterministic=True)
+
+        async for data in bidirectional_bytes(call, encoded()):
+            response = _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket()
+            response.ParseFromString(data)
+            yield response
+
+    async def do_nothing(
+        self, request: _google_protobuf_empty_pb2.Empty
+    ) -> _google_protobuf_empty_pb2.Empty:
+        call = await self._client.open_call(
+            self._service, "DoNothing", request.SerializeToString(deterministic=True)
+        )
+        try:
+            data = await call.receive()
+            if data is None:
+                raise CallProtocolError("missing unary response")
+            response = _google_protobuf_empty_pb2.Empty()
+            response.ParseFromString(data)
+            if await call.receive() is not None:
+                raise CallProtocolError("extra unary response")
+            return response
+        finally:
+            await call.aclose()
+
+
+class EchoerServer(Protocol):
+    async def echo(
+        self, request: _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+    ) -> _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg: ...
+    def echo_server_stream(
+        self, request: _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+    ) -> AsyncIterator[_github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg]: ...
+    async def echo_client_stream(
+        self,
+        requests: AsyncIterator[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ],
+    ) -> _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg: ...
+    def echo_bidi_stream(
+        self,
+        requests: AsyncIterator[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ],
+    ) -> AsyncIterator[_github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg]: ...
+    def rpc_stream(
+        self,
+        requests: AsyncIterator[
+            _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket
+        ],
+    ) -> AsyncIterator[
+        _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket
+    ]: ...
+    async def do_nothing(
+        self, request: _google_protobuf_empty_pb2.Empty
+    ) -> _google_protobuf_empty_pb2.Empty: ...
+
+
+def register_echoer(
+    registry: ServiceRegistry,
+    implementation: EchoerServer,
+    service: str = "echo.Echoer",
+) -> None:
+    async def echo_handler(call: Call) -> None:
+        first = await call.receive()
+        if first is None:
+            raise CallProtocolError("missing initial request")
+        request = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+        request.ParseFromString(first)
+        response = await implementation.echo(request)
+        await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "Echo", echo_handler)
+
+    async def echo_server_stream_handler(call: Call) -> None:
+        first = await call.receive()
+        if first is None:
+            raise CallProtocolError("missing initial request")
+        request = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+        request.ParseFromString(first)
+        async for response in implementation.echo_server_stream(request):
+            await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "EchoServerStream", echo_server_stream_handler)
+
+    async def echo_client_stream_handler(call: Call) -> None:
+        async def requests() -> AsyncIterator[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ]:
+            while True:
+                data = await call.receive()
+                if data is None:
+                    return
+                request = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+                request.ParseFromString(data)
+                yield request
+
+        response = await implementation.echo_client_stream(requests())
+        await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "EchoClientStream", echo_client_stream_handler)
+
+    async def echo_bidi_stream_handler(call: Call) -> None:
+        async def requests() -> AsyncIterator[
+            _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg
+        ]:
+            while True:
+                data = await call.receive()
+                if data is None:
+                    return
+                request = _github_com_aperturerobotics_starpc_echo_echo_pb2.EchoMsg()
+                request.ParseFromString(data)
+                yield request
+
+        async for response in implementation.echo_bidi_stream(requests()):
+            await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "EchoBidiStream", echo_bidi_stream_handler)
+
+    async def rpc_stream_handler(call: Call) -> None:
+        async def requests() -> AsyncIterator[
+            _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket
+        ]:
+            while True:
+                data = await call.receive()
+                if data is None:
+                    return
+                request = _github_com_aperturerobotics_starpc_rpcstream_rpcstream_pb2.RpcStreamPacket()
+                request.ParseFromString(data)
+                yield request
+
+        async for response in implementation.rpc_stream(requests()):
+            await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "RpcStream", rpc_stream_handler)
+
+    async def do_nothing_handler(call: Call) -> None:
+        first = await call.receive()
+        if first is None:
+            raise CallProtocolError("missing initial request")
+        request = _google_protobuf_empty_pb2.Empty()
+        request.ParseFromString(first)
+        response = await implementation.do_nothing(request)
+        await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "DoNothing", do_nothing_handler)