@stream-io/video-client 1.50.0 → 1.52.0

package/src/devices/__tests__/DeviceManager.test.ts

@@ -17,7 +17,7 @@ import {
 } from './mocks';
 import { DeviceManager } from '../DeviceManager';
 import { DeviceManagerState } from '../DeviceManagerState';
-import { of } from 'rxjs';
+import { firstValueFrom, of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { PermissionsContext } from '../../permissions';
 import { readPreferences } from '../devicePersistence';
@@ -25,7 +25,9 @@ import { readPreferences } from '../devicePersistence';
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
   return {
-    Call: vi.fn(() => mockCall()),
+    Call: vi.fn(function () {
+      return mockCall();
+    }),
   };
 });
 
@@ -221,6 +223,126 @@ describe('Device Manager', () => {
     expect(spy.mock.calls.length).toBe(1);
   });
 
+  it('should use a virtual device stream factory instead of requesting a real device stream', async () => {
+    const virtualStream = mockVideoStream();
+    const getUserMedia = vi.fn(() => ({ stream: virtualStream }));
+
+    const { deviceId } = manager.registerVirtualDevice({
+      label: 'Virtual camera',
+      getUserMedia,
+    });
+
+    await manager.select(deviceId);
+    await manager.enable();
+
+    expect(getUserMedia).toHaveBeenCalledOnce();
+    expect(getUserMedia).toHaveBeenCalledWith({
+      deviceId: { exact: deviceId },
+    });
+    expect(manager.getStream).not.toHaveBeenCalled();
+    expect(manager.state.mediaStream).toBe(virtualStream);
+    expect(manager.state.selectedDevice).toBe(deviceId);
+  });
+
+  it('should call virtual device stop when switching away from it', async () => {
+    const stop = vi.fn();
+    const virtualStream = mockVideoStream();
+
+    const { deviceId } = manager.registerVirtualDevice({
+      label: 'Virtual camera',
+      getUserMedia: vi.fn(() => ({ stream: virtualStream, stop })),
+    });
+
+    await manager.select(deviceId);
+    await manager.enable();
+    await manager.select(mockVideoDevices[1].deviceId);
+
+    expect(stop).toHaveBeenCalledTimes(1);
+  });
+
+  it('should support an async getUserMedia returning a Promise', async () => {
+    const virtualStream = mockVideoStream();
+    const getUserMedia = vi.fn(() =>
+      Promise.resolve({ stream: virtualStream }),
+    );
+
+    const { deviceId } = manager.registerVirtualDevice({
+      label: 'Async virtual camera',
+      getUserMedia,
+    });
+
+    await manager.select(deviceId);
+    await manager.enable();
+
+    expect(getUserMedia).toHaveBeenCalledOnce();
+    expect(manager.state.mediaStream).toBe(virtualStream);
+    expect(manager.state.selectedDevice).toBe(deviceId);
+  });
+
+  it('should roll back selection when getUserMedia rejects', async () => {
+    const failure = new Error('factory boom');
+    const getUserMedia = vi.fn(() => Promise.reject(failure));
+
+    await manager.enable();
+    const previousDevice = manager.state.selectedDevice;
+
+    const { deviceId } = manager.registerVirtualDevice({
+      label: 'Failing camera',
+      getUserMedia,
+    });
+
+    await expect(manager.select(deviceId)).rejects.toThrow(failure);
+
+    expect(manager.state.selectedDevice).toBe(previousDevice);
+  });
+
+  it('should stop the active session and clear selection on unregister', async () => {
+    const stop = vi.fn();
+    const virtualStream = mockVideoStream();
+
+    const { deviceId, unregister } = manager.registerVirtualDevice({
+      label: 'Virtual camera',
+      getUserMedia: vi.fn(() => ({ stream: virtualStream, stop })),
+    });
+
+    await manager.select(deviceId);
+    await manager.enable();
+
+    await unregister();
+
+    expect(stop).toHaveBeenCalledTimes(1);
+    expect(manager.state.selectedDevice).not.toBe(deviceId);
+  });
+
+  it('should remove the entry on unregister without stopping when not selected', async () => {
+    const stop = vi.fn();
+    const getUserMedia = vi.fn(() => ({ stream: mockVideoStream(), stop }));
+
+    const { unregister } = manager.registerVirtualDevice({
+      label: 'Unused virtual camera',
+      getUserMedia,
+    });
+
+    await unregister();
+
+    expect(stop).not.toHaveBeenCalled();
+    expect(getUserMedia).not.toHaveBeenCalled();
+  });
+
+  it('should expose virtual devices via listDevices() with the provided label', async () => {
+    manager.registerVirtualDevice({
+      label: 'My virtual camera',
+      getUserMedia: vi.fn(() => ({ stream: mockVideoStream() })),
+    });
+
+    const devices = await firstValueFrom(manager.listDevices());
+
+    expect(devices.length).toBe(mockVideoDevices.length + 1);
+    const virtual = devices.find((d) => d.label === 'My virtual camera');
+    expect(virtual).toBeDefined();
+    expect(virtual?.kind).toBe('videoinput');
+  });
+
   it('should resume previously enabled state', async () => {
     vi.spyOn(manager, 'enable');
 

package/src/devices/__tests__/MicrophoneManager.test.ts

@@ -76,7 +76,9 @@ vi.mock('../../helpers/no-audio-detector.ts', () => {
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
   return {
-    Call: vi.fn(() => mockCall()),
+    Call: vi.fn(function () {
+      return mockCall();
+    }),
   };
 });
 

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -43,7 +43,9 @@ vi.mock('../devices.ts', () => {
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
   return {
-    Call: vi.fn(() => mockCall()),
+    Call: vi.fn(function () {
+      return mockCall();
+    }),
   };
 });
 

package/src/devices/__tests__/ScreenShareManager.test.ts

@@ -26,7 +26,9 @@ vi.mock('../devices.ts', () => {
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
   return {
-    Call: vi.fn(() => mockCall()),
+    Call: vi.fn(function () {
+      return mockCall();
+    }),
   };
 });
 

package/src/devices/__tests__/web-audio.mocks.ts

@@ -63,7 +63,9 @@ export const setupAudioContextMock = () => {
   const mockContext = createMockAudioContext();
   vi.stubGlobal(
     'AudioContext',
-    vi.fn(() => mockContext),
+    vi.fn(function () {
+      return mockContext;
+    }),
   );
   return mockContext;
 };

package/src/devices/devicePersistence.ts

@@ -48,8 +48,9 @@ export const normalize = (
 export const createSyntheticDevice = (
   deviceId: string,
   kind: MediaDeviceKind,
+  label = '',
 ): MediaDeviceInfo => {
-  return { deviceId, kind, label: '', groupId: '' } as MediaDeviceInfo;
+  return { deviceId, kind, label, groupId: '' } as MediaDeviceInfo;
 };
 
 export const readPreferences = (storageKey: string): LocalDevicePreferences => {

package/src/devices/index.ts

@@ -10,3 +10,4 @@ export * from './ScreenShareManager';
 export * from './ScreenShareState';
 export * from './SpeakerManager';
 export * from './SpeakerState';
+export * from './VirtualDevice';

package/src/gen/video/sfu/event/events.ts

@@ -675,6 +675,10 @@ export interface SubscriberOffer {
    * @generated from protobuf field: string sdp = 2;
    */
   sdp: string;
+  /**
+   * @generated from protobuf field: uint32 negotiation_id = 3;
+   */
+  negotiationId: number;
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.PublisherAnswer
@@ -1606,6 +1610,12 @@ class SubscriberOffer$Type extends MessageType<SubscriberOffer> {
     super('stream.video.sfu.event.SubscriberOffer', [
       { no: 1, name: 'ice_restart', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
       { no: 2, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 3,
+        name: 'negotiation_id',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
     ]);
   }
 }

package/src/gen/video/sfu/models/models.ts

@@ -453,6 +453,10 @@ export interface ClientDetails {
    * @generated from protobuf field: stream.video.sfu.models.Device device = 4;
    */
   device?: Device;
+  /**
+   * @generated from protobuf field: string webrtc_version = 5;
+   */
+  webrtcVersion: string;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Sdk
@@ -706,6 +710,155 @@ export interface PerformanceStats {
    */
   targetBitrate: number;
 }
+/**
+ * ===================================================================
+ * BASE (shared by all RTP directions)
+ * ===================================================================
+ *
+ * @generated from protobuf message stream.video.sfu.models.RtpBase
+ */
+export interface RtpBase {
+  /**
+   * @generated from protobuf field: uint32 ssrc = 1;
+   */
+  ssrc: number; // raw stat["ssrc"]
+  /**
+   * @generated from protobuf field: string kind = 2;
+   */
+  kind: string; // stat["kind"] ("audio","video")
+  /**
+   * @generated from protobuf field: double timestamp_ms = 3;
+   */
+  timestampMs: number; // stat["timestamp"] in milliseconds
+}
+/**
+ * ===================================================================
+ * INBOUND (SUBSCRIBER RECEIVING MEDIA)
+ * ===================================================================
+ *
+ * @generated from protobuf message stream.video.sfu.models.InboundRtp
+ */
+export interface InboundRtp {
+  /**
+   * @generated from protobuf field: stream.video.sfu.models.RtpBase base = 1;
+   */
+  base?: RtpBase;
+  /**
+   * @generated from protobuf field: double jitter_seconds = 2;
+   */
+  jitterSeconds: number; // stat["jitter"]
+  /**
+   * @generated from protobuf field: uint64 packets_received = 3;
+   */
+  packetsReceived: string; // stat["packetsReceived"]
+  /**
+   * @generated from protobuf field: uint64 packets_lost = 4;
+   */
+  packetsLost: string; // stat["packetsLost"]
+  /**
+   * @generated from protobuf field: double packet_loss_percent = 5;
+   */
+  packetLossPercent: number; // (packets_lost / (packets_received + packets_lost)) * 100;skip if denominator <= 0 or counters decreased
+  /**
+   * -------- AUDIO METRICS --------
+   *
+   * @generated from protobuf field: uint32 concealment_events = 10;
+   */
+  concealmentEvents: number; // stat["concealmentEvents"]
+  /**
+   * @generated from protobuf field: double concealment_percent = 11;
+   */
+  concealmentPercent: number; // (concealedSamples / totalSamplesReceived) * 100 when totalSamplesReceived >= 96_000 (≈2 s @ 48 kHz)
+  /**
+   * -------- VIDEO METRICS --------
+   *
+   * @generated from protobuf field: double fps = 20;
+   */
+  fps: number; // use delta(framesDecoded)/delta(time) with prev sample
+  /**
+   * @generated from protobuf field: double freeze_duration_seconds = 21;
+   */
+  freezeDurationSeconds: number; // stat["totalFreezesDuration"]
+  /**
+   * @generated from protobuf field: double avg_decode_time_seconds = 22;
+   */
+  avgDecodeTimeSeconds: number; // stat["totalDecodeTime"] / max(1, stat["framesDecoded"])
+  /**
+   * @generated from protobuf field: uint32 min_dimension_px = 23;
+   */
+  minDimensionPx: number; // min(stat["frameWidth"], stat["frameHeight"]) for video-like tracks
+}
+/**
+ * ===================================================================
+ * OUTBOUND (PUBLISHER SENDING MEDIA)
+ * ===================================================================
+ *
+ * @generated from protobuf message stream.video.sfu.models.OutboundRtp
+ */
+export interface OutboundRtp {
+  /**
+   * @generated from protobuf field: stream.video.sfu.models.RtpBase base = 1;
+   */
+  base?: RtpBase;
+  /**
+   * @generated from protobuf field: double fps = 10;
+   */
+  fps: number; // delta(framesEncoded)/delta(time) if missing
+  /**
+   * @generated from protobuf field: double avg_encode_time_seconds = 11;
+   */
+  avgEncodeTimeSeconds: number; // stat["totalEncodeTime"] / max(1, stat["framesEncoded"])
+  /**
+   * @generated from protobuf field: double bitrate_bps = 12;
+   */
+  bitrateBps: number; // delta(bytesSent)*8 / delta(timeSeconds); requires prev bytes/timestamp; ignore if delta<=0
+  /**
+   * @generated from protobuf field: uint32 min_dimension_px = 13;
+   */
+  minDimensionPx: number; // min(stat["frameWidth"], stat["frameHeight"])
+}
+/**
+ * ===================================================================
+ * SFU FEEDBACK: REMOTE-INBOUND (Publisher receives feedback)
+ * ===================================================================
+ *
+ * @generated from protobuf message stream.video.sfu.models.RemoteInboundRtp
+ */
+export interface RemoteInboundRtp {
+  /**
+   * @generated from protobuf field: stream.video.sfu.models.RtpBase base = 1;
+   */
+  base?: RtpBase;
+  /**
+   * @generated from protobuf field: double jitter_seconds = 2;
+   */
+  jitterSeconds: number; // stat["jitter"]
+  /**
+   * @generated from protobuf field: double round_trip_time_s = 3;
+   */
+  roundTripTimeS: number; // stat["roundTripTime"]
+}
+/**
+ * ===================================================================
+ * SFU FEEDBACK: REMOTE-OUTBOUND (Subscriber receives feedback)
+ * ===================================================================
+ *
+ * @generated from protobuf message stream.video.sfu.models.RemoteOutboundRtp
+ */
+export interface RemoteOutboundRtp {
+  /**
+   * @generated from protobuf field: stream.video.sfu.models.RtpBase base = 1;
+   */
+  base?: RtpBase;
+  /**
+   * @generated from protobuf field: double jitter_seconds = 2;
+   */
+  jitterSeconds: number; // stat["jitter"] if provided
+  /**
+   * @generated from protobuf field: double round_trip_time_s = 3;
+   */
+  roundTripTimeS: number; // stat["roundTripTime"]
+}
 /**
  * @generated from protobuf enum stream.video.sfu.models.PeerType
  */
@@ -973,6 +1126,14 @@ export enum SdkType {
    * @generated from protobuf enum value: SDK_TYPE_PLAIN_JAVASCRIPT = 9;
    */
   PLAIN_JAVASCRIPT = 9,
+  /**
+   * @generated from protobuf enum value: SDK_TYPE_PYTHON = 10;
+   */
+  PYTHON = 10,
+  /**
+   * @generated from protobuf enum value: SDK_TYPE_VISION_AGENTS = 11;
+   */
+  VISION_AGENTS = 11,
 }
 /**
  * @generated from protobuf enum stream.video.sfu.models.TrackUnpublishReason
@@ -1177,6 +1338,12 @@ export enum ClientCapability {
    * @generated from protobuf enum value: CLIENT_CAPABILITY_SUBSCRIBER_VIDEO_PAUSE = 1;
    */
   SUBSCRIBER_VIDEO_PAUSE = 1,
+  /**
+   * Instructs SFU that stats will be sent to the coordinator
+   *
+   * @generated from protobuf enum value: CLIENT_CAPABILITY_COORDINATOR_STATS = 2;
+   */
+  COORDINATOR_STATS = 2,
 }
 /**
  * DegradationPreference represents the RTCDegradationPreference from WebRTC.
@@ -1641,6 +1808,12 @@ class ClientDetails$Type extends MessageType<ClientDetails> {
       { no: 2, name: 'os', kind: 'message', T: () => OS },
       { no: 3, name: 'browser', kind: 'message', T: () => Browser },
       { no: 4, name: 'device', kind: 'message', T: () => Device },
+      {
+        no: 5,
+        name: 'webrtc_version',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
     ]);
   }
 }
@@ -1913,3 +2086,168 @@ class PerformanceStats$Type extends MessageType<PerformanceStats> {
  * @generated MessageType for protobuf message stream.video.sfu.models.PerformanceStats
  */
 export const PerformanceStats = new PerformanceStats$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RtpBase$Type extends MessageType<RtpBase> {
+  constructor() {
+    super('stream.video.sfu.models.RtpBase', [
+      { no: 1, name: 'ssrc', kind: 'scalar', T: 13 /*ScalarType.UINT32*/ },
+      { no: 2, name: 'kind', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 3,
+        name: 'timestamp_ms',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RtpBase
+ */
+export const RtpBase = new RtpBase$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InboundRtp$Type extends MessageType<InboundRtp> {
+  constructor() {
+    super('stream.video.sfu.models.InboundRtp', [
+      { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+      {
+        no: 2,
+        name: 'jitter_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 3,
+        name: 'packets_received',
+        kind: 'scalar',
+        T: 4 /*ScalarType.UINT64*/,
+      },
+      {
+        no: 4,
+        name: 'packets_lost',
+        kind: 'scalar',
+        T: 4 /*ScalarType.UINT64*/,
+      },
+      {
+        no: 5,
+        name: 'packet_loss_percent',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 10,
+        name: 'concealment_events',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
+      {
+        no: 11,
+        name: 'concealment_percent',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      { no: 20, name: 'fps', kind: 'scalar', T: 1 /*ScalarType.DOUBLE*/ },
+      {
+        no: 21,
+        name: 'freeze_duration_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 22,
+        name: 'avg_decode_time_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 23,
+        name: 'min_dimension_px',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.InboundRtp
+ */
+export const InboundRtp = new InboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OutboundRtp$Type extends MessageType<OutboundRtp> {
+  constructor() {
+    super('stream.video.sfu.models.OutboundRtp', [
+      { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+      { no: 10, name: 'fps', kind: 'scalar', T: 1 /*ScalarType.DOUBLE*/ },
+      {
+        no: 11,
+        name: 'avg_encode_time_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 12,
+        name: 'bitrate_bps',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 13,
+        name: 'min_dimension_px',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.OutboundRtp
+ */
+export const OutboundRtp = new OutboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteInboundRtp$Type extends MessageType<RemoteInboundRtp> {
+  constructor() {
+    super('stream.video.sfu.models.RemoteInboundRtp', [
+      { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+      {
+        no: 2,
+        name: 'jitter_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 3,
+        name: 'round_trip_time_s',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RemoteInboundRtp
+ */
+export const RemoteInboundRtp = new RemoteInboundRtp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteOutboundRtp$Type extends MessageType<RemoteOutboundRtp> {
+  constructor() {
+    super('stream.video.sfu.models.RemoteOutboundRtp', [
+      { no: 1, name: 'base', kind: 'message', T: () => RtpBase },
+      {
+        no: 2,
+        name: 'jitter_seconds',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+      {
+        no: 3,
+        name: 'round_trip_time_s',
+        kind: 'scalar',
+        T: 1 /*ScalarType.DOUBLE*/,
+      },
+    ]);
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.RemoteOutboundRtp
+ */
+export const RemoteOutboundRtp = new RemoteOutboundRtp$Type();

package/src/gen/video/sfu/signal_rpc/signal.client.ts

@@ -14,6 +14,8 @@ import type {
   ICETrickleResponse,
   SendAnswerRequest,
   SendAnswerResponse,
+  SendMetricsRequest,
+  SendMetricsResponse,
   SendStatsRequest,
   SendStatsResponse,
   SetPublisherRequest,
@@ -92,6 +94,13 @@ export interface ISignalServerClient {
     input: SendStatsRequest,
     options?: RpcOptions,
   ): UnaryCall<SendStatsRequest, SendStatsResponse>;
+  /**
+   * @generated from protobuf rpc: SendMetrics(stream.video.sfu.signal.SendMetricsRequest) returns (stream.video.sfu.signal.SendMetricsResponse);
+   */
+  sendMetrics(
+    input: SendMetricsRequest,
+    options?: RpcOptions,
+  ): UnaryCall<SendMetricsRequest, SendMetricsResponse>;
   /**
    * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
    */
@@ -240,6 +249,23 @@ export class SignalServerClient implements ISignalServerClient, ServiceInfo {
       input,
     );
   }
+  /**
+   * @generated from protobuf rpc: SendMetrics(stream.video.sfu.signal.SendMetricsRequest) returns (stream.video.sfu.signal.SendMetricsResponse);
+   */
+  sendMetrics(
+    input: SendMetricsRequest,
+    options?: RpcOptions,
+  ): UnaryCall<SendMetricsRequest, SendMetricsResponse> {
+    const method = this.methods[7],
+      opt = this._transport.mergeOptions(options);
+    return stackIntercept<SendMetricsRequest, SendMetricsResponse>(
+      'unary',
+      this._transport,
+      method,
+      opt,
+      input,
+    );
+  }
   /**
    * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
    */
@@ -247,7 +273,7 @@ export class SignalServerClient implements ISignalServerClient, ServiceInfo {
     input: StartNoiseCancellationRequest,
     options?: RpcOptions,
   ): UnaryCall<StartNoiseCancellationRequest, StartNoiseCancellationResponse> {
-    const method = this.methods[7],
+    const method = this.methods[8],
       opt = this._transport.mergeOptions(options);
     return stackIntercept<
       StartNoiseCancellationRequest,
@@ -261,7 +287,7 @@ export class SignalServerClient implements ISignalServerClient, ServiceInfo {
     input: StopNoiseCancellationRequest,
     options?: RpcOptions,
   ): UnaryCall<StopNoiseCancellationRequest, StopNoiseCancellationResponse> {
-    const method = this.methods[8],
+    const method = this.methods[9],
       opt = this._transport.mergeOptions(options);
     return stackIntercept<
       StopNoiseCancellationRequest,