starpc 0.4.9 → 0.5.0

package/echo/echo.pb.go

@@ -10,6 +10,7 @@ import (
 	reflect "reflect"
 	sync "sync"
 
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 )
@@ -75,22 +76,31 @@ var file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDesc = []byte{
 	0x0a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x65,
 	0x72, 0x74, 0x75, 0x72, 0x65, 0x72, 0x6f, 0x62, 0x6f, 0x74, 0x69, 0x63, 0x73, 0x2f, 0x73, 0x74,
 	0x61, 0x72, 0x70, 0x63, 0x2f, 0x65, 0x63, 0x68, 0x6f, 0x2f, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x65, 0x63, 0x68, 0x6f, 0x22, 0x1d, 0x0a, 0x07, 0x45, 0x63,
-	0x68, 0x6f, 0x4d, 0x73, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x32, 0xca, 0x01, 0x0a, 0x06, 0x45, 0x63,
-	0x68, 0x6f, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x04, 0x45, 0x63, 0x68, 0x6f, 0x12, 0x0d, 0x2e, 0x65,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x65, 0x63, 0x68, 0x6f, 0x1a, 0x3c, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x65, 0x72, 0x74, 0x75, 0x72, 0x65, 0x72,
+	0x6f, 0x62, 0x6f, 0x74, 0x69, 0x63, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x72, 0x70, 0x63, 0x2f, 0x72,
+	0x70, 0x63, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2f, 0x72, 0x70, 0x63, 0x73, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x1d, 0x0a, 0x07, 0x45, 0x63, 0x68, 0x6f,
+	0x4d, 0x73, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x32, 0x93, 0x02, 0x0a, 0x06, 0x45, 0x63, 0x68, 0x6f,
+	0x65, 0x72, 0x12, 0x24, 0x0a, 0x04, 0x45, 0x63, 0x68, 0x6f, 0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68,
+	0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f,
+	0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x12, 0x32, 0x0a, 0x10, 0x45, 0x63, 0x68, 0x6f,
+	0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x0d, 0x2e, 0x65,
 	0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63,
-	0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x12, 0x32, 0x0a, 0x10, 0x45, 0x63,
-	0x68, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x0d,
-	0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e,
-	0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x30, 0x01, 0x12, 0x32,
-	0x0a, 0x10, 0x45, 0x63, 0x68, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65,
+	0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x30, 0x01, 0x12, 0x32, 0x0a, 0x10,
+	0x45, 0x63, 0x68, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a,
+	0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x28, 0x01,
+	0x12, 0x32, 0x0a, 0x0e, 0x45, 0x63, 0x68, 0x6f, 0x42, 0x69, 0x64, 0x69, 0x53, 0x74, 0x72, 0x65,
 	0x61, 0x6d, 0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73,
 	0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67,
-	0x28, 0x01, 0x12, 0x32, 0x0a, 0x0e, 0x45, 0x63, 0x68, 0x6f, 0x42, 0x69, 0x64, 0x69, 0x53, 0x74,
-	0x72, 0x65, 0x61, 0x6d, 0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f,
-	0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d,
-	0x73, 0x67, 0x28, 0x01, 0x30, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x28, 0x01, 0x30, 0x01, 0x12, 0x47, 0x0a, 0x09, 0x52, 0x70, 0x63, 0x53, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x12, 0x1a, 0x2e, 0x72, 0x70, 0x63, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x52, 0x70,
+	0x63, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x1a, 0x1a, 0x2e,
+	0x72, 0x70, 0x63, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x52, 0x70, 0x63, 0x53, 0x74, 0x72,
+	0x65, 0x61, 0x6d, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x28, 0x01, 0x30, 0x01, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -107,19 +117,22 @@ func file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescGZIP() []byt
 
 var file_github_com_aperturerobotics_starpc_echo_echo_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
 var file_github_com_aperturerobotics_starpc_echo_echo_proto_goTypes = []interface{}{
-	(*EchoMsg)(nil), // 0: echo.EchoMsg
+	(*EchoMsg)(nil),                   // 0: echo.EchoMsg
+	(*rpcstream.RpcStreamPacket)(nil), // 1: rpcstream.RpcStreamPacket
 }
 var file_github_com_aperturerobotics_starpc_echo_echo_proto_depIdxs = []int32{
 	0, // 0: echo.Echoer.Echo:input_type -> echo.EchoMsg
 	0, // 1: echo.Echoer.EchoServerStream:input_type -> echo.EchoMsg
 	0, // 2: echo.Echoer.EchoClientStream:input_type -> echo.EchoMsg
 	0, // 3: echo.Echoer.EchoBidiStream:input_type -> echo.EchoMsg
-	0, // 4: echo.Echoer.Echo:output_type -> echo.EchoMsg
-	0, // 5: echo.Echoer.EchoServerStream:output_type -> echo.EchoMsg
-	0, // 6: echo.Echoer.EchoClientStream:output_type -> echo.EchoMsg
-	0, // 7: echo.Echoer.EchoBidiStream:output_type -> echo.EchoMsg
-	4, // [4:8] is the sub-list for method output_type
-	0, // [0:4] is the sub-list for method input_type
+	1, // 4: echo.Echoer.RpcStream:input_type -> rpcstream.RpcStreamPacket
+	0, // 5: echo.Echoer.Echo:output_type -> echo.EchoMsg
+	0, // 6: echo.Echoer.EchoServerStream:output_type -> echo.EchoMsg
+	0, // 7: echo.Echoer.EchoClientStream:output_type -> echo.EchoMsg
+	0, // 8: echo.Echoer.EchoBidiStream:output_type -> echo.EchoMsg
+	1, // 9: echo.Echoer.RpcStream:output_type -> rpcstream.RpcStreamPacket
+	5, // [5:10] is the sub-list for method output_type
+	0, // [0:5] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name

package/echo/echo.pb.ts

@@ -1,8 +1,8 @@
 /* eslint-disable */
 import Long from 'long'
+import { EchoMsg as EchoMsg1 } from './echo.pb.js'
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
 import * as _m0 from 'protobufjs/minimal'
-import { Observable } from 'rxjs'
-import { map } from 'rxjs/operators'
 
 export const protobufPackage = 'echo'
 
@@ -44,6 +44,40 @@ export const EchoMsg = {
     return message
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<EchoMsg, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [EchoMsg.encode(p).finish()]
+        }
+      } else {
+        yield* [EchoMsg.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, EchoMsg>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<EchoMsg> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [EchoMsg.decode(p)]
+        }
+      } else {
+        yield* [EchoMsg.decode(pkt)]
+      }
+    }
+  },
+
   fromJSON(object: any): EchoMsg {
     return {
       body: isSet(object.body) ? String(object.body) : '',
@@ -66,13 +100,17 @@ export const EchoMsg = {
 /** Echoer service returns the given message. */
 export interface Echoer {
   /** Echo returns the given message. */
-  Echo(request: EchoMsg): Promise<EchoMsg>
+  Echo(request: EchoMsg1): Promise<EchoMsg1>
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg): Observable<EchoMsg>
+  EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1>
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg>
+  EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1>
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg>
+  EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1>
+  /** RpcStream opens a nested rpc call stream. */
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket>
 }
 
 export class EchoerClientImpl implements Echoer {
@@ -83,45 +121,54 @@ export class EchoerClientImpl implements Echoer {
     this.EchoServerStream = this.EchoServerStream.bind(this)
     this.EchoClientStream = this.EchoClientStream.bind(this)
     this.EchoBidiStream = this.EchoBidiStream.bind(this)
+    this.RpcStream = this.RpcStream.bind(this)
   }
-  Echo(request: EchoMsg): Promise<EchoMsg> {
-    const data = EchoMsg.encode(request).finish()
+  Echo(request: EchoMsg1): Promise<EchoMsg1> {
+    const data = EchoMsg1.encode(request).finish()
     const promise = this.rpc.request('echo.Echoer', 'Echo', data)
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+    return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)))
   }
 
-  EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
-    const data = EchoMsg.encode(request).finish()
+  EchoServerStream(request: EchoMsg1): AsyncIterable<EchoMsg1> {
+    const data = EchoMsg1.encode(request).finish()
     const result = this.rpc.serverStreamingRequest(
       'echo.Echoer',
       'EchoServerStream',
       data
     )
-    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+    return EchoMsg1.decodeTransform(result)
   }
 
-  EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
-    const data = request.pipe(
-      map((request) => EchoMsg.encode(request).finish())
-    )
+  EchoClientStream(request: AsyncIterable<EchoMsg1>): Promise<EchoMsg1> {
+    const data = EchoMsg1.encodeTransform(request)
     const promise = this.rpc.clientStreamingRequest(
       'echo.Echoer',
       'EchoClientStream',
       data
     )
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+    return promise.then((data) => EchoMsg1.decode(new _m0.Reader(data)))
   }
 
-  EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
-    const data = request.pipe(
-      map((request) => EchoMsg.encode(request).finish())
-    )
+  EchoBidiStream(request: AsyncIterable<EchoMsg1>): AsyncIterable<EchoMsg1> {
+    const data = EchoMsg1.encodeTransform(request)
     const result = this.rpc.bidirectionalStreamingRequest(
       'echo.Echoer',
       'EchoBidiStream',
       data
     )
-    return result.pipe(map((data) => EchoMsg.decode(new _m0.Reader(data))))
+    return EchoMsg1.decodeTransform(result)
+  }
+
+  RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket> {
+    const data = RpcStreamPacket.encodeTransform(request)
+    const result = this.rpc.bidirectionalStreamingRequest(
+      'echo.Echoer',
+      'RpcStream',
+      data
+    )
+    return RpcStreamPacket.decodeTransform(result)
   }
 }
 
@@ -134,36 +181,45 @@ export const EchoerDefinition = {
     /** Echo returns the given message. */
     echo: {
       name: 'Echo',
-      requestType: EchoMsg,
+      requestType: EchoMsg1,
       requestStream: false,
-      responseType: EchoMsg,
+      responseType: EchoMsg1,
       responseStream: false,
       options: {},
     },
     /** EchoServerStream is an example of a server -> client one-way stream. */
     echoServerStream: {
       name: 'EchoServerStream',
-      requestType: EchoMsg,
+      requestType: EchoMsg1,
       requestStream: false,
-      responseType: EchoMsg,
+      responseType: EchoMsg1,
       responseStream: true,
       options: {},
     },
     /** EchoClientStream is an example of client->server one-way stream. */
     echoClientStream: {
       name: 'EchoClientStream',
-      requestType: EchoMsg,
+      requestType: EchoMsg1,
       requestStream: true,
-      responseType: EchoMsg,
+      responseType: EchoMsg1,
       responseStream: false,
       options: {},
     },
     /** EchoBidiStream is an example of a two-way stream. */
     echoBidiStream: {
       name: 'EchoBidiStream',
-      requestType: EchoMsg,
+      requestType: EchoMsg1,
+      requestStream: true,
+      responseType: EchoMsg1,
+      responseStream: true,
+      options: {},
+    },
+    /** RpcStream opens a nested rpc call stream. */
+    rpcStream: {
+      name: 'RpcStream',
+      requestType: RpcStreamPacket,
       requestStream: true,
-      responseType: EchoMsg,
+      responseType: RpcStreamPacket,
       responseStream: true,
       options: {},
     },
@@ -179,18 +235,18 @@ interface Rpc {
   clientStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
   ): Promise<Uint8Array>
   serverStreamingRequest(
     service: string,
     method: string,
     data: Uint8Array
-  ): Observable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
-  ): Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
 }
 
 type Builtin =

package/echo/echo.proto

@@ -1,6 +1,8 @@
 syntax = "proto3";
 package echo;
 
+import "github.com/aperturerobotics/starpc/rpcstream/rpcstream.proto";
+
 // Echoer service returns the given message.
 service Echoer {
   // Echo returns the given message.
@@ -11,6 +13,8 @@ service Echoer {
   rpc EchoClientStream(stream EchoMsg) returns (EchoMsg);
   // EchoBidiStream is an example of a two-way stream.
   rpc EchoBidiStream(stream EchoMsg) returns (stream EchoMsg);
+  // RpcStream opens a nested rpc call stream.
+  rpc RpcStream(stream .rpcstream.RpcStreamPacket) returns (stream .rpcstream.RpcStreamPacket);
 }
 
 // EchoMsg is the message body for Echo.

package/echo/echo_srpc.pb.go

@@ -7,6 +7,7 @@ package echo
 import (
 	context "context"
 
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
 	srpc "github.com/aperturerobotics/starpc/srpc"
 )
 
@@ -17,6 +18,7 @@ type SRPCEchoerClient interface {
 	EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error)
 	EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error)
 	EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error)
+	RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error)
 }
 
 type srpcEchoerClient struct {
@@ -149,11 +151,48 @@ func (x *srpcEchoer_EchoBidiStreamClient) RecvTo(m *EchoMsg) error {
 	return x.MsgRecv(m)
 }
 
+func (c *srpcEchoerClient) RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "RpcStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcEchoer_RpcStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCEchoer_RpcStreamClient interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+	RecvTo(*rpcstream.RpcStreamPacket) error
+}
+
+type srpcEchoer_RpcStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_RpcStreamClient) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_RpcStreamClient) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_RpcStreamClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}
+
 type SRPCEchoerServer interface {
 	Echo(context.Context, *EchoMsg) (*EchoMsg, error)
 	EchoServerStream(*EchoMsg, SRPCEchoer_EchoServerStreamStream) error
 	EchoClientStream(SRPCEchoer_EchoClientStreamStream) error
 	EchoBidiStream(SRPCEchoer_EchoBidiStreamStream) error
+	RpcStream(SRPCEchoer_RpcStreamStream) error
 }
 
 type SRPCEchoerUnimplementedServer struct{}
@@ -174,6 +213,10 @@ func (s *SRPCEchoerUnimplementedServer) EchoBidiStream(SRPCEchoer_EchoBidiStream
 	return srpc.ErrUnimplemented
 }
 
+func (s *SRPCEchoerUnimplementedServer) RpcStream(SRPCEchoer_RpcStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
 const SRPCEchoerServiceID = "echo.Echoer"
 
 type SRPCEchoerHandler struct {
@@ -188,6 +231,7 @@ func (SRPCEchoerHandler) GetMethodIDs() []string {
 		"EchoServerStream",
 		"EchoClientStream",
 		"EchoBidiStream",
+		"RpcStream",
 	}
 }
 
@@ -208,6 +252,8 @@ func (d *SRPCEchoerHandler) InvokeMethod(
 		return true, d.InvokeMethod_EchoClientStream(d.impl, strm)
 	case "EchoBidiStream":
 		return true, d.InvokeMethod_EchoBidiStream(d.impl, strm)
+	case "RpcStream":
+		return true, d.InvokeMethod_RpcStream(d.impl, strm)
 	default:
 		return false, nil
 	}
@@ -244,6 +290,11 @@ func (SRPCEchoerHandler) InvokeMethod_EchoBidiStream(impl SRPCEchoerServer, strm
 	return impl.EchoBidiStream(clientStrm)
 }
 
+func (SRPCEchoerHandler) InvokeMethod_RpcStream(impl SRPCEchoerServer, strm srpc.Stream) error {
+	clientStrm := &srpcEchoer_RpcStreamStream{strm}
+	return impl.RpcStream(clientStrm)
+}
+
 func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
 	return mux.Register(&SRPCEchoerHandler{impl: impl})
 }
@@ -331,3 +382,29 @@ func (x *srpcEchoer_EchoBidiStreamStream) Recv() (*EchoMsg, error) {
 func (x *srpcEchoer_EchoBidiStreamStream) RecvTo(m *EchoMsg) error {
 	return x.MsgRecv(m)
 }
+
+type SRPCEchoer_RpcStreamStream interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+}
+
+type srpcEchoer_RpcStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcEchoer_RpcStreamStream) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcEchoer_RpcStreamStream) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcEchoer_RpcStreamStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}

package/echo/server.go

@@ -6,11 +6,19 @@ import (
 	"io"
 	"time"
 
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
+	srpc "github.com/aperturerobotics/starpc/srpc"
 	"google.golang.org/protobuf/proto"
 )
 
 // EchoServer implements the server side of Echo.
 type EchoServer struct {
+	rpcStreamMux srpc.Mux
+}
+
+// NewEchoServer constructs a EchoServer with a RpcStream mux.
+func NewEchoServer(rpcStreamMux srpc.Mux) *EchoServer {
+	return &EchoServer{rpcStreamMux: rpcStreamMux}
 }
 
 // Echo implements echo.SRPCEchoerServer
@@ -69,5 +77,15 @@ func (s *EchoServer) EchoBidiStream(strm SRPCEchoer_EchoBidiStreamStream) error
 	}
 }
 
+// RpcStream runs a rpc stream
+func (r *EchoServer) RpcStream(stream SRPCEchoer_RpcStreamStream) error {
+	return rpcstream.HandleRpcStream(stream, func(ctx context.Context, componentID string) (srpc.Mux, error) {
+		if r.rpcStreamMux == nil {
+			return nil, errors.New("not implemented")
+		}
+		return r.rpcStreamMux, nil
+	})
+}
+
 // _ is a type assertion
 var _ SRPCEchoerServer = ((*EchoServer)(nil))

package/echo/server.ts

@@ -1,57 +1,63 @@
-import { Observable, from as observableFrom } from 'rxjs'
 import { Echoer, EchoMsg } from './echo.pb.js'
 import { pushable, Pushable } from 'it-pushable'
+import first from 'it-first'
+import { Server } from '../srpc/server.js'
+import { writeToPushable } from '../srpc/pushable.js'
+import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
+import { handleRpcStream } from '../rpcstream/rpcstream.js'
 
 // EchoServer implements the Echoer server.
 export class EchoerServer implements Echoer {
+  // proxyServer is the server used for RpcStream requests.
+  private proxyServer?: Server
+
+  constructor(proxyServer?: Server) {
+    this.proxyServer = proxyServer
+  }
+
   public async Echo(request: EchoMsg): Promise<EchoMsg> {
     return request
   }
 
-  public EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
-    // send 5 responses, with a 200ms delay for each
-    return observableFrom(
-      (async function* response(): AsyncIterable<EchoMsg> {
-        for (let i = 0; i < 5; i++) {
-          yield request
-          await new Promise((resolve) => setTimeout(resolve, 200))
-        }
-      })()
-    )
+  public async *EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
+    for (let i = 0; i < 5; i++) {
+      yield request
+      await new Promise((resolve) => setTimeout(resolve, 200))
+    }
   }
 
-  public EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
-    return new Promise<EchoMsg>((resolve, reject) => {
-      request.subscribe({
-        next(msg) {
-          resolve(msg)
-        },
-        error(err: any) {
-          reject(err)
-        },
-        complete() {
-          reject(new Error('none received'))
-        },
-      })
-    })
+  public async EchoClientStream(
+    request: AsyncIterable<EchoMsg>
+  ): Promise<EchoMsg> {
+    // return the first message sent by the client.
+    const message = await first(request)
+    if (!message) {
+      throw new Error('received no messages')
+    }
+    return message
   }
 
-  public EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
+  public EchoBidiStream(
+    request: AsyncIterable<EchoMsg>
+  ): AsyncIterable<EchoMsg> {
     // build result observable
-    const pushResponse: Pushable<EchoMsg> = pushable({ objectMode: true })
-    const response = observableFrom(pushResponse)
-    pushResponse.push({ body: 'hello from server' })
-    request.subscribe({
-      next(msg) {
-        pushResponse.push(msg)
-      },
-      error(err) {
-        pushResponse.throw(err)
-      },
-      complete() {
-        pushResponse.end()
-      },
-    })
-    return response
+    const result: Pushable<EchoMsg> = pushable({ objectMode: true })
+    result.push({ body: 'hello from server' })
+    writeToPushable(request, result)
+    return result
+  }
+
+  public RpcStream(
+    request: AsyncIterable<RpcStreamPacket>
+  ): AsyncIterable<RpcStreamPacket> {
+    return handleRpcStream(
+      request[Symbol.asyncIterator](),
+      async (_componentId: string): Promise<Server> => {
+        if (!this.proxyServer) {
+          throw new Error('rpc stream proxy server not set')
+        }
+        return this.proxyServer
+      }
+    )
   }
 }

package/integration/integration.go

@@ -11,8 +11,7 @@ import (
 
 func main() {
 	mux := srpc.NewMux()
-
-	echoServer := &echo.EchoServer{}
+	echoServer := echo.NewEchoServer(mux)
 	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
 		logrus.Fatal(err.Error())
 	}

package/integration/integration.ts

@@ -1,5 +1,5 @@
 import { WebSocketConn } from '../srpc/websocket.js'
-import { runClientTest } from '../echo/client-test.js'
+import { runClientTest, runRpcStreamTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {
@@ -9,7 +9,11 @@ async function runRPC() {
   const channel = new WebSocketConn(ws)
   const client = channel.buildClient()
 
+  console.log('Running client test via WebSocket..')
   await runClientTest(client)
+
+  console.log('Running RpcStream test via WebSocket..')
+  await runRpcStreamTest(client)
 }
 
 runRPC()