starpc 0.11.0 → 0.11.2

package/dist/srpc/rpcproto.pb.js

@@ -1,16 +1,16 @@
 /* eslint-disable */
-import Long from 'long';
-import _m0 from 'protobufjs/minimal.js';
-export const protobufPackage = 'srpc';
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
+export const protobufPackage = "srpc";
 function createBasePacket() {
     return { body: undefined };
 }
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === 'callStart') {
+        if (message.body?.$case === "callStart") {
             CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
         }
-        if (message.body?.$case === 'callData') {
+        if (message.body?.$case === "callData") {
             CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
         }
         return writer;
@@ -23,16 +23,10 @@ export const Packet = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.body = {
-                        $case: 'callStart',
-                        callStart: CallStart.decode(reader, reader.uint32()),
-                    };
+                    message.body = { $case: "callStart", callStart: CallStart.decode(reader, reader.uint32()) };
                     break;
                 case 2:
-                    message.body = {
-                        $case: 'callData',
-                        callData: CallData.decode(reader, reader.uint32()),
-                    };
+                    message.body = { $case: "callData", callData: CallData.decode(reader, reader.uint32()) };
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -72,62 +66,40 @@ export const Packet = {
     fromJSON(object) {
         return {
             body: isSet(object.callStart)
-                ? {
-                    $case: 'callStart',
-                    callStart: CallStart.fromJSON(object.callStart),
-                }
+                ? { $case: "callStart", callStart: CallStart.fromJSON(object.callStart) }
                 : isSet(object.callData)
-                    ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
+                    ? { $case: "callData", callData: CallData.fromJSON(object.callData) }
                     : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        message.body?.$case === 'callStart' &&
-            (obj.callStart = message.body?.callStart
-                ? CallStart.toJSON(message.body?.callStart)
-                : undefined);
-        message.body?.$case === 'callData' &&
-            (obj.callData = message.body?.callData
-                ? CallData.toJSON(message.body?.callData)
-                : undefined);
+        message.body?.$case === "callStart" &&
+            (obj.callStart = message.body?.callStart ? CallStart.toJSON(message.body?.callStart) : undefined);
+        message.body?.$case === "callData" &&
+            (obj.callData = message.body?.callData ? CallData.toJSON(message.body?.callData) : undefined);
         return obj;
     },
     fromPartial(object) {
         const message = createBasePacket();
-        if (object.body?.$case === 'callStart' &&
-            object.body?.callStart !== undefined &&
-            object.body?.callStart !== null) {
-            message.body = {
-                $case: 'callStart',
-                callStart: CallStart.fromPartial(object.body.callStart),
-            };
+        if (object.body?.$case === "callStart" && object.body?.callStart !== undefined && object.body?.callStart !== null) {
+            message.body = { $case: "callStart", callStart: CallStart.fromPartial(object.body.callStart) };
         }
-        if (object.body?.$case === 'callData' &&
-            object.body?.callData !== undefined &&
-            object.body?.callData !== null) {
-            message.body = {
-                $case: 'callData',
-                callData: CallData.fromPartial(object.body.callData),
-            };
+        if (object.body?.$case === "callData" && object.body?.callData !== undefined && object.body?.callData !== null) {
+            message.body = { $case: "callData", callData: CallData.fromPartial(object.body.callData) };
         }
         return message;
     },
 };
 function createBaseCallStart() {
-    return {
-        rpcService: '',
-        rpcMethod: '',
-        data: new Uint8Array(),
-        dataIsZero: false,
-    };
+    return { rpcService: "", rpcMethod: "", data: new Uint8Array(), dataIsZero: false };
 }
 export const CallStart = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.rpcService !== '') {
+        if (message.rpcService !== "") {
             writer.uint32(10).string(message.rpcService);
         }
-        if (message.rpcMethod !== '') {
+        if (message.rpcMethod !== "") {
             writer.uint32(18).string(message.rpcMethod);
         }
         if (message.data.length !== 0) {
@@ -194,11 +166,9 @@ export const CallStart = {
     },
     fromJSON(object) {
         return {
-            rpcService: isSet(object.rpcService) ? String(object.rpcService) : '',
-            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : '',
-            data: isSet(object.data)
-                ? bytesFromBase64(object.data)
-                : new Uint8Array(),
+            rpcService: isSet(object.rpcService) ? String(object.rpcService) : "",
+            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : "",
+            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
         };
     },
@@ -213,20 +183,15 @@ export const CallStart = {
     },
     fromPartial(object) {
         const message = createBaseCallStart();
-        message.rpcService = object.rpcService ?? '';
-        message.rpcMethod = object.rpcMethod ?? '';
+        message.rpcService = object.rpcService ?? "";
+        message.rpcMethod = object.rpcMethod ?? "";
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         return message;
     },
 };
 function createBaseCallData() {
-    return {
-        data: new Uint8Array(),
-        dataIsZero: false,
-        complete: false,
-        error: '',
-    };
+    return { data: new Uint8Array(), dataIsZero: false, complete: false, error: "" };
 }
 export const CallData = {
     encode(message, writer = _m0.Writer.create()) {
@@ -239,7 +204,7 @@ export const CallData = {
         if (message.complete === true) {
             writer.uint32(24).bool(message.complete);
         }
-        if (message.error !== '') {
+        if (message.error !== "") {
             writer.uint32(34).string(message.error);
         }
         return writer;
@@ -300,12 +265,10 @@ export const CallData = {
     },
     fromJSON(object) {
         return {
-            data: isSet(object.data)
-                ? bytesFromBase64(object.data)
-                : new Uint8Array(),
+            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
             complete: isSet(object.complete) ? Boolean(object.complete) : false,
-            error: isSet(object.error) ? String(object.error) : '',
+            error: isSet(object.error) ? String(object.error) : "",
         };
     },
     toJSON(message) {
@@ -322,28 +285,28 @@ export const CallData = {
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         message.complete = object.complete ?? false;
-        message.error = object.error ?? '';
+        message.error = object.error ?? "";
         return message;
     },
 };
 var globalThis = (() => {
-    if (typeof globalThis !== 'undefined') {
+    if (typeof globalThis !== "undefined") {
         return globalThis;
     }
-    if (typeof self !== 'undefined') {
+    if (typeof self !== "undefined") {
         return self;
     }
-    if (typeof window !== 'undefined') {
+    if (typeof window !== "undefined") {
         return window;
     }
-    if (typeof global !== 'undefined') {
+    if (typeof global !== "undefined") {
         return global;
     }
-    throw 'Unable to locate global object';
+    throw "Unable to locate global object";
 })();
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
     }
     else {
         const bin = globalThis.atob(b64);
@@ -356,14 +319,14 @@ function bytesFromBase64(b64) {
 }
 function base64FromBytes(arr) {
     if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString('base64');
+        return globalThis.Buffer.from(arr).toString("base64");
     }
     else {
         const bin = [];
         arr.forEach((byte) => {
             bin.push(String.fromCharCode(byte));
         });
-        return globalThis.btoa(bin.join(''));
+        return globalThis.btoa(bin.join(""));
     }
 }
 if (_m0.util.Long !== Long) {

package/echo/echo.pb.ts

@@ -1,60 +1,57 @@
 /* eslint-disable */
-import Long from 'long'
-import _m0 from 'protobufjs/minimal.js'
-import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
+import { RpcStreamPacket } from "../rpcstream/rpcstream.pb.js";
 
-export const protobufPackage = 'echo'
+export const protobufPackage = "echo";
 
 /** EchoMsg is the message body for Echo. */
 export interface EchoMsg {
-  body: string
+  body: string;
 }
 
 function createBaseEchoMsg(): EchoMsg {
-  return { body: '' }
+  return { body: "" };
 }
 
 export const EchoMsg = {
-  encode(
-    message: EchoMsg,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.body !== '') {
-      writer.uint32(10).string(message.body)
+  encode(message: EchoMsg, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.body !== "") {
+      writer.uint32(10).string(message.body);
     }
-    return writer
+    return writer;
   },
 
   decode(input: _m0.Reader | Uint8Array, length?: number): EchoMsg {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
-    let end = length === undefined ? reader.len : reader.pos + length
-    const message = createBaseEchoMsg()
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEchoMsg();
     while (reader.pos < end) {
-      const tag = reader.uint32()
+      const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.body = reader.string()
-          break
+          message.body = reader.string();
+          break;
         default:
-          reader.skipType(tag & 7)
-          break
+          reader.skipType(tag & 7);
+          break;
       }
     }
-    return message
+    return message;
   },
 
   // encodeTransform encodes a source of message objects.
   // Transform<EchoMsg, Uint8Array>
   async *encodeTransform(
-    source: AsyncIterable<EchoMsg | EchoMsg[]> | Iterable<EchoMsg | EchoMsg[]>
+    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()]
+          yield* [EchoMsg.encode(p).finish()];
         }
       } else {
-        yield* [EchoMsg.encode(pkt).finish()]
+        yield* [EchoMsg.encode(pkt).finish()];
       }
     }
   },
@@ -62,122 +59,102 @@ export const EchoMsg = {
   // decodeTransform decodes a source of encoded messages.
   // Transform<Uint8Array, EchoMsg>
   async *decodeTransform(
-    source:
-      | AsyncIterable<Uint8Array | Uint8Array[]>
-      | Iterable<Uint8Array | Uint8Array[]>
+    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)]
+          yield* [EchoMsg.decode(p)];
         }
       } else {
-        yield* [EchoMsg.decode(pkt)]
+        yield* [EchoMsg.decode(pkt)];
       }
     }
   },
 
   fromJSON(object: any): EchoMsg {
-    return { body: isSet(object.body) ? String(object.body) : '' }
+    return { body: isSet(object.body) ? String(object.body) : "" };
   },
 
   toJSON(message: EchoMsg): unknown {
-    const obj: any = {}
-    message.body !== undefined && (obj.body = message.body)
-    return obj
+    const obj: any = {};
+    message.body !== undefined && (obj.body = message.body);
+    return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<EchoMsg>, I>>(object: I): EchoMsg {
-    const message = createBaseEchoMsg()
-    message.body = object.body ?? ''
-    return message
+    const message = createBaseEchoMsg();
+    message.body = object.body ?? "";
+    return message;
   },
-}
+};
 
 /** Echoer service returns the given message. */
 export interface Echoer {
   /** Echo returns the given message. */
-  Echo(request: EchoMsg): Promise<EchoMsg>
+  Echo(request: EchoMsg): Promise<EchoMsg>;
   /** EchoServerStream is an example of a server -> client one-way stream. */
-  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>
+  EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
   /** EchoClientStream is an example of client->server one-way stream. */
-  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>
+  EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;
   /** EchoBidiStream is an example of a two-way stream. */
-  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>
+  EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg>;
   /** RpcStream opens a nested rpc call stream. */
-  RpcStream(
-    request: AsyncIterable<RpcStreamPacket>
-  ): AsyncIterable<RpcStreamPacket>
+  RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket>;
 }
 
 export class EchoerClientImpl implements Echoer {
-  private readonly rpc: Rpc
-  constructor(rpc: Rpc) {
-    this.rpc = rpc
-    this.Echo = this.Echo.bind(this)
-    this.EchoServerStream = this.EchoServerStream.bind(this)
-    this.EchoClientStream = this.EchoClientStream.bind(this)
-    this.EchoBidiStream = this.EchoBidiStream.bind(this)
-    this.RpcStream = this.RpcStream.bind(this)
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, service?: string) {
+    this.service = service || "echo.Echoer";
+    this.rpc = rpc;
+    this.Echo = this.Echo.bind(this);
+    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()
-    const promise = this.rpc.request('echo.Echoer', 'Echo', data)
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+    const data = EchoMsg.encode(request).finish();
+    const promise = this.rpc.request(this.service, "Echo", data);
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
   }
 
   EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
-    const data = EchoMsg.encode(request).finish()
-    const result = this.rpc.serverStreamingRequest(
-      'echo.Echoer',
-      'EchoServerStream',
-      data
-    )
-    return EchoMsg.decodeTransform(result)
+    const data = EchoMsg.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "EchoServerStream", data);
+    return EchoMsg.decodeTransform(result);
   }
 
   EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
-    const data = EchoMsg.encodeTransform(request)
-    const promise = this.rpc.clientStreamingRequest(
-      'echo.Echoer',
-      'EchoClientStream',
-      data
-    )
-    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)))
+    const data = EchoMsg.encodeTransform(request);
+    const promise = this.rpc.clientStreamingRequest(this.service, "EchoClientStream", data);
+    return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
   }
 
   EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
-    const data = EchoMsg.encodeTransform(request)
-    const result = this.rpc.bidirectionalStreamingRequest(
-      'echo.Echoer',
-      'EchoBidiStream',
-      data
-    )
-    return EchoMsg.decodeTransform(result)
+    const data = EchoMsg.encodeTransform(request);
+    const result = this.rpc.bidirectionalStreamingRequest(this.service, "EchoBidiStream", data);
+    return EchoMsg.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)
+  RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket> {
+    const data = RpcStreamPacket.encodeTransform(request);
+    const result = this.rpc.bidirectionalStreamingRequest(this.service, "RpcStream", data);
+    return RpcStreamPacket.decodeTransform(result);
   }
 }
 
 /** Echoer service returns the given message. */
-export type EchoerDefinition = typeof EchoerDefinition
+export type EchoerDefinition = typeof EchoerDefinition;
 export const EchoerDefinition = {
-  name: 'Echoer',
-  fullName: 'echo.Echoer',
+  name: "Echoer",
+  fullName: "echo.Echoer",
   methods: {
     /** Echo returns the given message. */
     echo: {
-      name: 'Echo',
+      name: "Echo",
       requestType: EchoMsg,
       requestStream: false,
       responseType: EchoMsg,
@@ -186,7 +163,7 @@ export const EchoerDefinition = {
     },
     /** EchoServerStream is an example of a server -> client one-way stream. */
     echoServerStream: {
-      name: 'EchoServerStream',
+      name: "EchoServerStream",
       requestType: EchoMsg,
       requestStream: false,
       responseType: EchoMsg,
@@ -195,7 +172,7 @@ export const EchoerDefinition = {
     },
     /** EchoClientStream is an example of client->server one-way stream. */
     echoClientStream: {
-      name: 'EchoClientStream',
+      name: "EchoClientStream",
       requestType: EchoMsg,
       requestStream: true,
       responseType: EchoMsg,
@@ -204,7 +181,7 @@ export const EchoerDefinition = {
     },
     /** EchoBidiStream is an example of a two-way stream. */
     echoBidiStream: {
-      name: 'EchoBidiStream',
+      name: "EchoBidiStream",
       requestType: EchoMsg,
       requestStream: true,
       responseType: EchoMsg,
@@ -213,7 +190,7 @@ export const EchoerDefinition = {
     },
     /** RpcStream opens a nested rpc call stream. */
     rpcStream: {
-      name: 'RpcStream',
+      name: "RpcStream",
       requestType: RpcStreamPacket,
       requestStream: true,
       responseType: RpcStreamPacket,
@@ -221,68 +198,37 @@ export const EchoerDefinition = {
       options: {},
     },
   },
-} as const
+} as const;
 
 interface Rpc {
-  request(
-    service: string,
-    method: string,
-    data: Uint8Array
-  ): Promise<Uint8Array>
-  clientStreamingRequest(
-    service: string,
-    method: string,
-    data: AsyncIterable<Uint8Array>
-  ): Promise<Uint8Array>
-  serverStreamingRequest(
-    service: string,
-    method: string,
-    data: Uint8Array
-  ): AsyncIterable<Uint8Array>
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+  clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+  serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: AsyncIterable<Uint8Array>
-  ): AsyncIterable<Uint8Array>
+    data: AsyncIterable<Uint8Array>,
+  ): AsyncIterable<Uint8Array>;
 }
 
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 
-export type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Long
-  ? string | number | Long
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends { $case: string }
-  ? { [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]> } & {
-      $case: T['$case']
-    }
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : Partial<T>
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
 
-type KeysOfUnion<T> = T extends T ? keyof T : never
-export type Exact<P, I extends P> = P extends Builtin
-  ? P
-  : P & { [K in keyof P]: Exact<P[K], I[K]> } & {
-      [K in Exclude<keyof I, KeysOfUnion<P>>]: never
-    }
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
 if (_m0.util.Long !== Long) {
-  _m0.util.Long = Long as any
-  _m0.configure()
+  _m0.util.Long = Long as any;
+  _m0.configure();
 }
 
 function isSet(value: any): boolean {
-  return value !== null && value !== undefined
+  return value !== null && value !== undefined;
 }

package/echo/echo_srpc.pb.go

@@ -22,18 +22,26 @@ type SRPCEchoerClient interface {
 }
 
 type srpcEchoerClient struct {
-	cc srpc.Client
+	cc        srpc.Client
+	serviceID string
 }
 
 func NewSRPCEchoerClient(cc srpc.Client) SRPCEchoerClient {
-	return &srpcEchoerClient{cc}
+	return &srpcEchoerClient{cc: cc, serviceID: SRPCEchoerServiceID}
+}
+
+func NewSRPCEchoerClientWithServiceID(cc srpc.Client, serviceID string) SRPCEchoerClient {
+	if serviceID == "" {
+		serviceID = SRPCEchoerServiceID
+	}
+	return &srpcEchoerClient{cc: cc, serviceID: serviceID}
 }
 
 func (c *srpcEchoerClient) SRPCClient() srpc.Client { return c.cc }
 
 func (c *srpcEchoerClient) Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, error) {
 	out := new(EchoMsg)
-	err := c.cc.Invoke(ctx, "echo.Echoer", "Echo", in, out)
+	err := c.cc.Invoke(ctx, c.serviceID, "Echo", in, out)
 	if err != nil {
 		return nil, err
 	}
@@ -41,7 +49,7 @@ func (c *srpcEchoerClient) Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, err
 }
 
 func (c *srpcEchoerClient) EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoServerStream", in)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoServerStream", in)
 	if err != nil {
 		return nil, err
 	}
@@ -75,7 +83,7 @@ func (x *srpcEchoer_EchoServerStreamClient) RecvTo(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoClientStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoClientStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -116,7 +124,7 @@ func (x *srpcEchoer_EchoClientStreamClient) CloseAndMsgRecv(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoBidiStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoBidiStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +160,7 @@ func (x *srpcEchoer_EchoBidiStreamClient) RecvTo(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "RpcStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "RpcStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -238,6 +246,7 @@ func NewSRPCEchoerHandler(impl SRPCEchoerServer, serviceID string) srpc.Handler
 func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
 	return mux.Register(NewSRPCEchoerHandler(impl, ""))
 }
+
 func (d *SRPCEchoerHandler) GetServiceID() string { return d.serviceID }
 
 func (SRPCEchoerHandler) GetMethodIDs() []string {