diff --git a/service/README.md b/service/README.md
index 2a4c381..f834f74 100644
--- a/service/README.md
+++ b/service/README.md
@@ -204,6 +204,41 @@ Terminates the active call session.
 #### `activeCall: E2ECall | null`
 Getter that returns the current active call object.
 
+An active call also exposes local audio controls:
+
+```typescript
+call.mute();
+call.unmute();
+call.setMuted(true);
+console.log(call.muted);
+
+await call.switchInputDevice('microphone-device-id');
+await call.setOutputDevice('speaker-device-id');
+
+const metrics = await call.getStatsSnapshot();
+console.log(metrics.localAudioLevel);
+```
+
+`mute()` keeps the microphone track alive and toggles its `enabled` property;
+ending a call stops the track. Switching microphones uses
+`RTCRtpSender.replaceTrack()` and stops the previous track after replacement
+succeeds. If replacement fails, the previous track remains active and the new
+track is cleaned up.
+
+`setOutputDevice()` requires the browser's `HTMLMediaElement.setSinkId()` API.
+Some browsers do not provide it, and supported browsers may require HTTPS and
+output-device permission. The method rejects with a descriptive error when
+selection is unavailable or denied without detaching the current audio.
+
+`getStatsSnapshot()` reports an optional local RMS audio level when
+`AudioContext` is available. Browser support, autoplay policies, and device
+permissions can vary; unsupported Web Audio environments return no level
+instead of interrupting the call. It also reports an optional
+`remoteAudioLevel` when `RTCPeerConnection.getStats()` exposes an inbound audio
+level; remote metrics are browser-dependent and are not guaranteed. Call cleanup closes meter contexts,
+detaches/removes remote audio elements, clears peer handlers, and stops media
+tracks.
+
 ---
 
 ### Events
diff --git a/service/src/webrtc/audioSink.test.ts b/service/src/webrtc/audioSink.test.ts
index aa2f3aa..793205c 100644
--- a/service/src/webrtc/audioSink.test.ts
+++ b/service/src/webrtc/audioSink.test.ts
@@ -8,6 +8,7 @@ function makeFakeAudioElement() {
         setAttribute: jest.fn((name: string, value: string) => { attributes[name] = value; }),
         getAttribute: (name: string) => attributes[name],
         play: jest.fn().mockResolvedValue(undefined),
+        remove: jest.fn(),
         srcObject: null as unknown,
     };
 }
@@ -16,9 +17,11 @@ describe('AudioSink', () => {
     let fakeAudioEl: ReturnType<typeof makeFakeAudioElement>;
     let createElement: jest.Mock;
     let appendChild: jest.Mock;
+    let originalHTMLMediaElement: unknown;
 
     beforeEach(() => {
         jest.useFakeTimers();
+        originalHTMLMediaElement = (globalThis as any).HTMLMediaElement;
         fakeAudioEl = makeFakeAudioElement();
         createElement = jest.fn().mockReturnValue(fakeAudioEl);
         appendChild = jest.fn();
@@ -32,6 +35,11 @@ describe('AudioSink', () => {
     afterEach(() => {
         jest.useRealTimers();
         delete (globalThis as any).document;
+        if (originalHTMLMediaElement) {
+            (globalThis as any).HTMLMediaElement = originalHTMLMediaElement;
+        } else {
+            delete (globalThis as any).HTMLMediaElement;
+        }
     });
 
     it('attach() creates an autoplaying <audio> element, sets the stream, and appends it to the DOM', async () => {
@@ -71,8 +79,48 @@ describe('AudioSink', () => {
         sink.detach();
 
         expect(fakeAudioEl.srcObject).toBeNull();
+        expect(fakeAudioEl.remove).toHaveBeenCalled();
 
         // detach() again should be a no-op and not throw.
         expect(() => sink.detach()).not.toThrow();
     });
+
+    it('setOutputDevice() delegates to setSinkId when supported', async () => {
+        const setSinkId = jest.fn().mockResolvedValue(undefined);
+        const mediaElement = class {};
+        (mediaElement.prototype as any).setSinkId = jest.fn();
+        (globalThis as any).HTMLMediaElement = mediaElement;
+        (fakeAudioEl as any).setSinkId = setSinkId;
+        const sink = new AudioSink(new Logger('test'));
+        await sink.attach({} as MediaStream, 'remote');
+
+        await sink.setOutputDevice('speaker-1');
+
+        expect(setSinkId).toHaveBeenCalledWith('speaker-1');
+    });
+
+    it('setOutputDevice() rejects clearly when the browser lacks setSinkId', async () => {
+        (globalThis as any).HTMLMediaElement = class {};
+        const sink = new AudioSink(new Logger('test'));
+        await sink.attach({} as MediaStream, 'remote');
+
+        await expect(sink.setOutputDevice('speaker-1')).rejects.toThrow(
+            'Output device selection is not supported by this browser.',
+        );
+    });
+
+    it('setOutputDevice() wraps permission or device failures without detaching audio', async () => {
+        const setSinkId = jest.fn().mockRejectedValue(new Error('permission denied'));
+        const mediaElement = class {};
+        (mediaElement.prototype as any).setSinkId = jest.fn();
+        (globalThis as any).HTMLMediaElement = mediaElement;
+        (fakeAudioEl as any).setSinkId = setSinkId;
+        const sink = new AudioSink(new Logger('test'));
+        await sink.attach({} as MediaStream, 'remote');
+
+        await expect(sink.setOutputDevice('speaker-1')).rejects.toThrow(
+            'Unable to select the output device.',
+        );
+        expect(fakeAudioEl.srcObject).not.toBeNull();
+    });
 });
diff --git a/service/src/webrtc/audioSink.ts b/service/src/webrtc/audioSink.ts
index c421d79..95d227d 100644
--- a/service/src/webrtc/audioSink.ts
+++ b/service/src/webrtc/audioSink.ts
@@ -12,6 +12,7 @@ export class AudioSink {
     constructor(private logger: Logger) {}
 
     public async attach(stream: MediaStream, tag: string): Promise<void> {
+        this.detach();
         this.logger.log('Adding remote audio track');
         this.audioEl = document.createElement('audio');
         this.audioEl.setAttribute('autoplay', 'true');
@@ -31,9 +32,37 @@ export class AudioSink {
         document.body.appendChild(this.audioEl);
     }
 
+    public async setOutputDevice(deviceId: string): Promise<void> {
+        if (!this.audioEl) {
+            throw new Error('No remote audio element is available for output device selection.');
+        }
+
+        // setSinkId is not available in every browser and may also require a
+        // secure context and permission for the selected output device.
+        if (typeof HTMLMediaElement === 'undefined' || !('setSinkId' in HTMLMediaElement.prototype)) {
+            throw new Error('Output device selection is not supported by this browser.');
+        }
+
+        const audioElement = this.audioEl as HTMLAudioElement & {
+            setSinkId: (sinkId: string) => Promise<void>;
+        };
+        try {
+            await audioElement.setSinkId(deviceId);
+        } catch (error) {
+            this.logger.log('Failed to set output device:', error);
+            const outputDeviceError = new Error(
+                'Unable to select the output device. Check browser permissions, device availability, and secure-context requirements.',
+            );
+            (outputDeviceError as Error & { cause?: unknown }).cause = error;
+            throw outputDeviceError;
+        }
+    }
+
     public detach(): void {
         if (this.audioEl) {
-            this.audioEl.srcObject = null;
+            const audioElement = this.audioEl;
+            audioElement.srcObject = null;
+            audioElement.remove();
             this.audioEl = undefined;
         }
     }
diff --git a/service/src/webrtc/peer.test.ts b/service/src/webrtc/peer.test.ts
index 975c7af..65104a7 100644
--- a/service/src/webrtc/peer.test.ts
+++ b/service/src/webrtc/peer.test.ts
@@ -6,6 +6,7 @@ import type { callEvents, WebRtcSignalPayload } from './types';
 // ---------------------------------------------------------------------------
 const mockAttach = jest.fn().mockResolvedValue(undefined);
 const mockDetach = jest.fn();
+let lastAudioContext: FakeAudioContext | undefined;
 jest.mock('./audioSink', () => ({
     AudioSink: jest.fn().mockImplementation(() => ({
         attach: mockAttach,
@@ -17,11 +18,12 @@ import { Peer } from './peer';
 
 interface FakeTrack {
     kind: string;
+    enabled: boolean;
     stop: jest.Mock;
 }
 
 function makeFakeTrack(kind = 'audio'): FakeTrack {
-    return { kind, stop: jest.fn() };
+    return { kind, enabled: true, stop: jest.fn() };
 }
 
 function makeFakeStream(tracks: FakeTrack[]) {
@@ -44,12 +46,38 @@ class FakeRTCPeerConnection {
     public addIceCandidate = jest.fn().mockResolvedValue(undefined);
     public close = jest.fn();
     public addTrack = jest.fn();
+    public getSenders = jest.fn();
+    public getStats = jest.fn().mockResolvedValue(new Map());
 
     constructor(public config: unknown) {}
 }
 
+class FakeAudioContext {
+    public source = {
+        connect: jest.fn(),
+        disconnect: jest.fn(),
+    };
+    public analyser = {
+        fftSize: 4,
+        getByteTimeDomainData: jest.fn((samples: Uint8Array) => {
+            samples.fill(128);
+            samples.set([128, 160, 96, 128]);
+            return samples;
+        }),
+    };
+    public close = jest.fn().mockResolvedValue(undefined);
+
+    constructor() {
+        lastAudioContext = this;
+    }
+
+    public createMediaStreamSource = jest.fn(() => this.source);
+    public createAnalyser = jest.fn(() => this.analyser);
+}
+
 function installWebRtcGlobals() {
     (globalThis as any).RTCPeerConnection = FakeRTCPeerConnection;
+    (globalThis as any).AudioContext = FakeAudioContext;
     (globalThis as any).RTCSessionDescription = class {
         type: string; sdp: string;
         constructor(init: { type: string; sdp: string }) { this.type = init.type; this.sdp = init.sdp; }
@@ -70,6 +98,8 @@ function uninstallWebRtcGlobals() {
     delete (globalThis as any).RTCSessionDescription;
     delete (globalThis as any).RTCIceCandidate;
     delete (globalThis as any).navigator;
+    delete (globalThis as any).AudioContext;
+    lastAudioContext = undefined;
 }
 
 async function createPeer(subs: Map<callEvents, Set<Function>> = new Map()): Promise<{ peer: Peer; pc: FakeRTCPeerConnection; sendSignal: jest.Mock }> {
@@ -202,6 +232,97 @@ describe('Peer', () => {
         expect(mockAttach).toHaveBeenCalledWith(remoteStream, 'remote');
     });
 
+    it('mute controls toggle the local audio track without stopping it', async () => {
+        const { peer } = await createPeer();
+        const localStream = await (globalThis as any).navigator.mediaDevices.getUserMedia.mock.results[0].value;
+        const localTrack = localStream.getAudioTracks()[0] as FakeTrack;
+
+        expect(peer.muted).toBe(false);
+
+        peer.mute();
+        expect(localTrack.enabled).toBe(false);
+        expect(peer.muted).toBe(true);
+        expect(localTrack.stop).not.toHaveBeenCalled();
+
+        peer.mute();
+        expect(localTrack.enabled).toBe(false);
+
+        peer.setMuted(false);
+        expect(localTrack.enabled).toBe(true);
+        expect(peer.muted).toBe(false);
+
+        peer.unmute();
+        expect(localTrack.enabled).toBe(true);
+        expect(localTrack.stop).not.toHaveBeenCalled();
+    });
+
+    it('switchInputDevice replaces and stops the local audio track while preserving mute state', async () => {
+        const { peer, pc } = await createPeer();
+        const getUserMedia = (globalThis as any).navigator.mediaDevices.getUserMedia;
+        const oldStream = await getUserMedia.mock.results[0].value;
+        const oldTrack = oldStream.getAudioTracks()[0] as FakeTrack;
+        const newTrack = makeFakeTrack('audio');
+        const newStream = makeFakeStream([newTrack]);
+        const replaceTrack = jest.fn().mockResolvedValue(undefined);
+        pc.getSenders.mockReturnValue([{ track: oldTrack, replaceTrack }]);
+        getUserMedia.mockResolvedValueOnce(newStream);
+
+        peer.mute();
+        await peer.switchInputDevice('mic-2');
+
+        expect(getUserMedia).toHaveBeenLastCalledWith({
+            audio: { deviceId: { exact: 'mic-2' } },
+            video: false,
+        });
+        expect(replaceTrack).toHaveBeenCalledWith(newTrack);
+        expect(newTrack.enabled).toBe(false);
+        expect(oldTrack.stop).toHaveBeenCalledTimes(1);
+        expect(peer.muted).toBe(true);
+    });
+
+    it('switchInputDevice stops the new track and preserves the old track when replacement fails', async () => {
+        const { peer, pc } = await createPeer();
+        const getUserMedia = (globalThis as any).navigator.mediaDevices.getUserMedia;
+        const oldStream = await getUserMedia.mock.results[0].value;
+        const oldTrack = oldStream.getAudioTracks()[0] as FakeTrack;
+        const newTrack = makeFakeTrack('audio');
+        const replaceTrack = jest.fn().mockRejectedValue(new Error('replace failed'));
+        pc.getSenders.mockReturnValue([{ track: oldTrack, replaceTrack }]);
+        getUserMedia.mockResolvedValueOnce(makeFakeStream([newTrack]));
+
+        await expect(peer.switchInputDevice('mic-3')).rejects.toThrow('replace failed');
+
+        expect(newTrack.stop).toHaveBeenCalledTimes(1);
+        expect(oldTrack.stop).not.toHaveBeenCalled();
+        expect(peer.muted).toBe(false);
+    });
+
+    it('getStatsSnapshot() returns local and remote audio levels and closes the meter on dispose', async () => {
+        const { peer, pc } = await createPeer();
+        pc.getStats.mockResolvedValue(new Map([
+            ['inbound-audio', { type: 'inbound-rtp', kind: 'audio', audioLevel: 0.4 }],
+        ]));
+
+        const stats = await peer.getStatsSnapshot();
+        const audioContext = lastAudioContext!;
+
+        expect(stats.localAudioLevel).toBeCloseTo(Math.sqrt(0.125 / 256), 5);
+        expect(stats.remoteAudioLevel).toBe(0.4);
+        expect(audioContext.source.connect).toHaveBeenCalled();
+
+        peer.dispose();
+
+        expect(audioContext.source.disconnect).toHaveBeenCalled();
+        expect(audioContext.close).toHaveBeenCalled();
+    });
+
+    it('getStatsSnapshot() fails safe when AudioContext is unavailable', async () => {
+        const { peer } = await createPeer();
+        delete (globalThis as any).AudioContext;
+
+        await expect(peer.getStatsSnapshot()).resolves.toEqual({});
+    });
+
     it('dispose() stops local tracks, detaches audio, and closes the connection', async () => {
         const { peer, pc } = await createPeer();
 
@@ -209,5 +330,7 @@ describe('Peer', () => {
 
         expect(mockDetach).toHaveBeenCalled();
         expect(pc.close).toHaveBeenCalled();
+        expect(() => peer.dispose()).not.toThrow();
+        expect(pc.close).toHaveBeenCalledTimes(1);
     });
 });
diff --git a/service/src/webrtc/peer.ts b/service/src/webrtc/peer.ts
index 00924fa..c436a01 100644
--- a/service/src/webrtc/peer.ts
+++ b/service/src/webrtc/peer.ts
@@ -7,6 +7,7 @@ import {
     type AnswerSignalData,
     type IceCandidateSignalWithMetadata,
     type SignalMetadata,
+    type CallStatsSnapshot,
 } from "./types";
 import { AudioSink } from "./audioSink";
 
@@ -38,6 +39,9 @@ export class Peer {
 
     private audioSink: AudioSink;
     private audioStream?: MediaStream;
+    private audioContext?: AudioContext;
+    private localAudioSource?: MediaStreamAudioSourceNode;
+    private localAudioAnalyser?: AnalyserNode;
     private fallbackSignalSeq = 0;
     private fallbackCallId = generateUUID();
 
@@ -91,6 +95,87 @@ export class Peer {
         return this.state;
     }
 
+    public get muted(): boolean {
+        return !(this.audioStream?.getAudioTracks()[0]?.enabled ?? true);
+    }
+
+    public mute(): void {
+        this.setMuted(true);
+    }
+
+    public unmute(): void {
+        this.setMuted(false);
+    }
+
+    public setMuted(mute: boolean): void {
+        const audioTrack = this.audioStream?.getAudioTracks()[0];
+        if (audioTrack) {
+            audioTrack.enabled = !mute;
+        }
+    }
+
+    public setOutputDevice(deviceId: string): Promise<void> {
+        return this.audioSink.setOutputDevice(deviceId);
+    }
+
+    public async getStatsSnapshot(): Promise<CallStatsSnapshot> {
+        await this.localStreamAcquisatonPromise;
+        this.initializeLocalAudioMeter();
+
+        const snapshot: CallStatsSnapshot = {};
+        if (this.localAudioAnalyser) {
+            const samples = new Uint8Array(this.localAudioAnalyser.fftSize);
+            this.localAudioAnalyser.getByteTimeDomainData(samples);
+            let sumOfSquares = 0;
+            for (const sample of samples) {
+                const normalizedSample = (sample - 128) / 128;
+                sumOfSquares += normalizedSample * normalizedSample;
+            }
+            snapshot.localAudioLevel = Math.sqrt(sumOfSquares / samples.length);
+        }
+
+        const remoteAudioLevel = await this.getRemoteAudioLevel();
+        if (typeof remoteAudioLevel === 'number') {
+            snapshot.remoteAudioLevel = remoteAudioLevel;
+        }
+        return snapshot;
+    }
+
+    public async switchInputDevice(deviceId: string): Promise<void> {
+        await this.localStreamAcquisatonPromise;
+
+        const oldAudioTrack = this.audioStream?.getAudioTracks()[0];
+        if (!oldAudioTrack) {
+            throw new Error('No local audio track is available to replace.');
+        }
+
+        const newStream = await this.getAudioStream(deviceId);
+        const newAudioTrack = newStream.getAudioTracks()[0];
+        if (!newAudioTrack) {
+            newStream.getTracks().forEach(track => track.stop());
+            throw new Error('The selected input device did not provide an audio track.');
+        }
+
+        const audioSender = this.pc.getSenders().find(sender => sender.track?.kind === 'audio');
+        if (!audioSender) {
+            newStream.getTracks().forEach(track => track.stop());
+            throw new Error('No local audio sender is available to replace.');
+        }
+
+        newAudioTrack.enabled = oldAudioTrack.enabled;
+        try {
+            await audioSender.replaceTrack(newAudioTrack);
+        } catch (error) {
+            newStream.getTracks().forEach(track => track.stop());
+            this.logger.log('Failed to switch input device:', error);
+            throw error;
+        }
+
+        oldAudioTrack.stop();
+        this.audioStream = newStream;
+        this.closeLocalAudioMeter();
+    }
+
     public async createAndSendOffer() {
         await this.localStreamAcquisatonPromise;
         this.logger.log('createAndSendOffer');
@@ -131,12 +216,19 @@ export class Peer {
     }
 
     public dispose(): void {
+        if (!this.pc) {
+            return;
+        }
         if(this.audioStream) {
             this.audioStream.getTracks().forEach(track => {
                 track.stop() ;
             });
             this.audioStream = undefined;
         }
+        this.closeLocalAudioMeter();
+        this.pc.onconnectionstatechange = null;
+        this.pc.onicecandidate = null;
+        this.pc.ontrack = null;
         this.audioSink.detach();
         this.logger.log('Dispose');
         this.pc?.close();
@@ -149,9 +241,85 @@ export class Peer {
         this.audioStream.getTracks().forEach(track => this.pc.addTrack(track, this.audioStream!));
     }
 
-    private async getAudioStream(): Promise<MediaStream> {
+    private initializeLocalAudioMeter(): void {
+        if (this.localAudioAnalyser || !this.audioStream) {
+            return;
+        }
+
+        // AudioContext is unavailable in some browsers and may be blocked by
+        // autoplay or permission policies, so metering must never break calls.
+        const audioContextConstructor = (globalThis as typeof globalThis & {
+            webkitAudioContext?: typeof AudioContext;
+        }).AudioContext ?? (globalThis as typeof globalThis & {
+            webkitAudioContext?: typeof AudioContext;
+        }).webkitAudioContext;
+        if (!audioContextConstructor) {
+            return;
+        }
+
+        try {
+            this.audioContext = new audioContextConstructor();
+            this.localAudioSource = this.audioContext.createMediaStreamSource(this.audioStream);
+            this.localAudioAnalyser = this.audioContext.createAnalyser();
+            this.localAudioAnalyser.fftSize = 256;
+            this.localAudioSource.connect(this.localAudioAnalyser);
+        } catch (error) {
+            this.logger.log('Local audio metering is unavailable:', error);
+            this.closeLocalAudioMeter();
+        }
+    }
+
+    private closeLocalAudioMeter(): void {
+        this.localAudioSource?.disconnect();
+        this.localAudioSource = undefined;
+        this.localAudioAnalyser = undefined;
+
+        const audioContext = this.audioContext;
+        this.audioContext = undefined;
+        if (audioContext) {
+            Promise.resolve(audioContext.close()).catch(error => {
+                this.logger.log('Failed to close local audio meter:', error);
+            });
+        }
+    }
+
+    private async getRemoteAudioLevel(): Promise<number | undefined> {
+        if (typeof this.pc?.getStats !== 'function') {
+            return undefined;
+        }
+
+        try {
+            const stats = await this.pc.getStats();
+            let remoteAudioLevel: number | undefined;
+            stats.forEach(report => {
+                if (report.type !== 'inbound-rtp') {
+                    return;
+                }
+                const inboundAudioReport = report as RTCInboundRtpStreamStats & {
+                    audioLevel?: number;
+                    kind?: string;
+                    mediaType?: string;
+                };
+                if (
+                    (inboundAudioReport.kind === 'audio' || inboundAudioReport.mediaType === 'audio') &&
+                    typeof inboundAudioReport.audioLevel === 'number'
+                ) {
+                    remoteAudioLevel = inboundAudioReport.audioLevel;
+                }
+            });
+            return remoteAudioLevel;
+        } catch (error) {
+            this.logger.log('Remote audio metering is unavailable:', error);
+            return undefined;
+        }
+    }
+
+    private async getAudioStream(deviceId?: string): Promise<MediaStream> {
         this.logger.log('getAudioStream');
-        return navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+        return navigator.mediaDevices.getUserMedia({
+            audio: deviceId ? { deviceId: { exact: deviceId } } : true,
+            video: false,
+        });
     }
 
     private resolveSignalMetadata(): SignalMetadata {
diff --git a/service/src/webrtc/types.ts b/service/src/webrtc/types.ts
index bc51d16..dc58cec 100644
--- a/service/src/webrtc/types.ts
+++ b/service/src/webrtc/types.ts
@@ -48,6 +48,11 @@ export interface SignalMetadata {
     timestamp: number;
 }
 
+export interface CallStatsSnapshot {
+    localAudioLevel?: number;
+    remoteAudioLevel?: number;
+}
+
 export interface OfferSignalData extends SignalData, SignalMetadata {
     type: 'offer';
 }
diff --git a/service/src/webrtc/webrtcCall.ts b/service/src/webrtc/webrtcCall.ts
index c9c5b9f..fb54fdc 100644
--- a/service/src/webrtc/webrtcCall.ts
+++ b/service/src/webrtc/webrtcCall.ts
@@ -6,16 +6,24 @@ import {
     type IceCandidateSignalWithMetadata,
     type OfferSignalData,
     type SignalMetadata,
+    type CallStatsSnapshot,
     type PeerConnectionEventType,
     peerConnectionEvents,
 } from "./types";
 
-export type { WebRtcSignalPayload, callEvents, PeerConnectionEventType };
+export type { WebRtcSignalPayload, callEvents, PeerConnectionEventType, CallStatsSnapshot };
 export { peerConnectionEvents };
 
 export interface IE2ECall {
     on(event: callEvents, cb: () => void): void;
     state: RTCPeerConnectionState;
+    readonly muted: boolean;
+    mute(): void;
+    unmute(): void;
+    setMuted(mute: boolean): void;
+    switchInputDevice(deviceId: string): Promise<void>;
+    setOutputDevice(deviceId: string): Promise<void>;
+    getStatsSnapshot(): Promise<CallStatsSnapshot>;
     endCall(): Promise<void>;
 }
 
@@ -62,6 +70,34 @@ export class WebRTCCall {
         return this.peer!.callState;
     }
 
+    public get muted(): boolean {
+        return this.peer!.muted;
+    }
+
+    public mute(): void {
+        this.peer!.mute();
+    }
+
+    public unmute(): void {
+        this.peer!.unmute();
+    }
+
+    public setMuted(mute: boolean): void {
+        this.peer!.setMuted(mute);
+    }
+
+    public switchInputDevice(deviceId: string): Promise<void> {
+        return this.peer!.switchInputDevice(deviceId);
+    }
+
+    public setOutputDevice(deviceId: string): Promise<void> {
+        return this.peer!.setOutputDevice(deviceId);
+    }
+
+    public getStatsSnapshot(): Promise<CallStatsSnapshot> {
+        return this.peer!.getStatsSnapshot();
+    }
+
     async startCall(): Promise<void> {
         this.logger.log('startCall');
         return this.peer!.createAndSendOffer();
@@ -228,6 +264,27 @@ export class E2ECall implements IE2ECall {
     public get state(): RTCPeerConnectionState {
         return this.webRtcCall.callState;
     }
+    public get muted(): boolean {
+        return this.webRtcCall.muted;
+    }
+    public mute(): void {
+        this.webRtcCall.mute();
+    }
+    public unmute(): void {
+        this.webRtcCall.unmute();
+    }
+    public setMuted(mute: boolean): void {
+        this.webRtcCall.setMuted(mute);
+    }
+    public switchInputDevice(deviceId: string): Promise<void> {
+        return this.webRtcCall.switchInputDevice(deviceId);
+    }
+    public setOutputDevice(deviceId: string): Promise<void> {
+        return this.webRtcCall.setOutputDevice(deviceId);
+    }
+    public getStatsSnapshot(): Promise<CallStatsSnapshot> {
+        return this.webRtcCall.getStatsSnapshot();
+    }
     public async endCall(): Promise<void> {
         return this.webRtcCall.endCall();
     }