livekit-client 2.18.9 → 2.19.0

package/src/room/rpc/client/RpcClientManager.test.ts

@@ -0,0 +1,430 @@
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import log from '../../../logger';
+import { subscribeToEvents } from '../../../utils/subscribeToEvents';
+import { CLIENT_PROTOCOL_DATA_STREAM_RPC, CLIENT_PROTOCOL_DEFAULT } from '../../../version';
+import type RTCEngine from '../../RTCEngine';
+import OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import { RPC_REQUEST_DATA_STREAM_TOPIC, RpcError, RpcRequestAttrs } from '../utils';
+import RpcClientManager from './RpcClientManager';
+import type { RpcClientManagerCallbacks } from './events';
+
+describe('RpcClientManager', () => {
+  describe('v2 -> v1', () => {
+    let rpcClientManager: RpcClientManager;
+
+    beforeEach(() => {
+      const outgoingDataStreamManager = new OutgoingDataStreamManager(
+        {} as unknown as RTCEngine,
+        log,
+      );
+
+      rpcClientManager = new RpcClientManager(
+        log,
+        outgoingDataStreamManager,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT, // (other participant is "v1")
+        () => undefined,
+      );
+    });
+
+    it('should send v1 RPC request to a "legacy" client (happy path)', async () => {
+      const managerEvents = subscribeToEvents<RpcClientManagerCallbacks>(rpcClientManager, [
+        'sendDataPacket',
+      ]);
+
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'remoteIdentity',
+        method: 'testMethod',
+        payload: 'testPayload',
+      });
+
+      // Verify exactly one packet was emitted
+      const { packet } = await managerEvents.waitFor('sendDataPacket');
+      assert(packet.value.case === 'rpcRequest');
+      expect(packet.value.value.id).toStrictEqual(requestId);
+      expect(packet.value.value.method).toStrictEqual('testMethod');
+      expect(packet.value.value.payload).toStrictEqual('testPayload');
+      expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
+
+      // Asynchronously send a response back
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      rpcClientManager.handleIncomingRpcResponseSuccess(requestId, 'response payload');
+
+      // Make sure the response came out the other end
+      const result = await completionPromise;
+      expect(result).toStrictEqual('response payload');
+    });
+
+    it('should fail to send long (> 15kb) v1 RPC request', async () => {
+      const longPayload = new Array<string>(20_000).fill('A').join('');
+
+      const performRpcPromise = rpcClientManager.performRpc({
+        destinationIdentity: 'destination-identity',
+        method: 'test-method',
+        payload: longPayload,
+      });
+
+      await expect(performRpcPromise).rejects.toThrow('Request payload too large');
+    });
+
+    it('should handle v1 RPC request timeout', async () => {
+      vi.useFakeTimers();
+
+      try {
+        const method = 'timeoutMethod';
+        const payload = 'timeoutPayload';
+        const timeout = 50;
+
+        const [, completionPromise] = await rpcClientManager.performRpc({
+          destinationIdentity: 'remote-identity',
+          method,
+          payload,
+          responseTimeout: timeout,
+        });
+
+        // Register the rejection handler before advancing so the rejection is caught
+        const rejectPromise = expect(completionPromise).rejects.toThrow('Response timeout');
+
+        // Response timeout (50ms) fires before ack timeout (7000ms)
+        await vi.advanceTimersByTimeAsync(timeout);
+
+        await rejectPromise;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('should handle v1 RPC error response', async () => {
+      const method = 'errorMethod';
+      const payload = 'errorPayload';
+      const errorCode = 101;
+      const errorMessage = 'Test error message';
+
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'remote-identity',
+        method,
+        payload,
+      });
+
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      rpcClientManager.handleIncomingRpcResponseFailure(
+        requestId,
+        new RpcError(errorCode, errorMessage),
+      );
+
+      await expect(completionPromise).rejects.toThrow(errorMessage);
+    });
+
+    it('should handle participant disconnection during v1 RPC request', async () => {
+      const method = 'disconnectMethod';
+      const payload = 'disconnectPayload';
+
+      const [, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'remote-identity',
+        method,
+        payload,
+      });
+
+      rpcClientManager.handleParticipantDisconnected('remote-identity');
+
+      await expect(completionPromise).rejects.toThrow('Recipient disconnected');
+    });
+  });
+
+  describe('v2 -> v2', () => {
+    let rpcClientManager: RpcClientManager;
+    let mockStreamTextWriter: {
+      write: ReturnType<typeof vi.fn>;
+      close: ReturnType<typeof vi.fn>;
+    };
+    let mockOutgoingDataStreamManager: OutgoingDataStreamManager;
+
+    beforeEach(() => {
+      mockStreamTextWriter = {
+        write: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+      };
+      mockOutgoingDataStreamManager = {
+        streamText: vi.fn().mockResolvedValue(mockStreamTextWriter),
+      } as unknown as OutgoingDataStreamManager;
+
+      rpcClientManager = new RpcClientManager(
+        log,
+        mockOutgoingDataStreamManager,
+        (_identity) => CLIENT_PROTOCOL_DATA_STREAM_RPC, // (other participant is "v2")
+        () => undefined,
+      );
+    });
+
+    function mockTextStreamReader(payload: string) {
+      return { readAll: vi.fn().mockResolvedValue(payload) } as any;
+    }
+
+    it('should send short v2 RPC request via data stream (happy path)', async () => {
+      const managerEvents = subscribeToEvents<RpcClientManagerCallbacks>(rpcClientManager, [
+        'sendDataPacket',
+      ]);
+
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'destination-identity',
+        method: 'test-method',
+        payload: 'request-payload',
+      });
+
+      // Verify the data stream was used with correct attributes
+      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: RPC_REQUEST_DATA_STREAM_TOPIC,
+          destinationIdentities: ['destination-identity'],
+          attributes: expect.objectContaining({
+            [RpcRequestAttrs.RPC_REQUEST_ID]: requestId,
+            [RpcRequestAttrs.RPC_REQUEST_METHOD]: 'test-method',
+            [RpcRequestAttrs.RPC_REQUEST_VERSION]: '2',
+          }),
+        }),
+      );
+      expect(mockStreamTextWriter.write).toHaveBeenCalledWith('request-payload');
+      expect(mockStreamTextWriter.close).toHaveBeenCalled();
+
+      // No packet should have been emitted
+      expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
+
+      // Asynchronously send a response back
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      await rpcClientManager.handleIncomingDataStream(
+        mockTextStreamReader('response-payload'),
+        'destination-identity',
+        { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+      );
+
+      await expect(completionPromise).resolves.toStrictEqual('response-payload');
+    });
+
+    it('should send long (> 15kb) v2 RPC request via data stream', async () => {
+      const managerEvents = subscribeToEvents<RpcClientManagerCallbacks>(rpcClientManager, [
+        'sendDataPacket',
+      ]);
+
+      const longPayload = new Array<string>(20_000).fill('A').join('');
+
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'destination-identity',
+        method: 'test-method',
+        payload: longPayload,
+      });
+
+      // Verify the data stream was used with correct attributes
+      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topic: RPC_REQUEST_DATA_STREAM_TOPIC,
+          destinationIdentities: ['destination-identity'],
+          attributes: expect.objectContaining({
+            [RpcRequestAttrs.RPC_REQUEST_ID]: requestId,
+            [RpcRequestAttrs.RPC_REQUEST_METHOD]: 'test-method',
+            [RpcRequestAttrs.RPC_REQUEST_VERSION]: '2',
+          }),
+        }),
+      );
+      expect(mockStreamTextWriter.write).toHaveBeenCalledWith(longPayload);
+      expect(mockStreamTextWriter.close).toHaveBeenCalled();
+
+      // No packet should have been emitted
+      expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
+
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      await rpcClientManager.handleIncomingDataStream(
+        mockTextStreamReader('response-payload'),
+        'destination-identity',
+        { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+      );
+
+      await expect(completionPromise).resolves.toStrictEqual('response-payload');
+    });
+
+    it('should handle a v2 RPC request timeout', async () => {
+      vi.useFakeTimers();
+
+      try {
+        const timeout = 50;
+
+        const [, completionPromise] = await rpcClientManager.performRpc({
+          destinationIdentity: 'remote-identity',
+          method: 'timeoutMethod',
+          payload: 'timeoutPayload',
+          responseTimeout: timeout,
+        });
+
+        const rejectPromise = expect(completionPromise).rejects.toThrow('Response timeout');
+        await vi.advanceTimersByTimeAsync(timeout);
+        await rejectPromise;
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('should handle a v2 RPC error response', async () => {
+      const errorCode = 101;
+      const errorMessage = 'Test error message';
+
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'remote-identity',
+        method: 'errorMethod',
+        payload: 'errorPayload',
+      });
+
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      rpcClientManager.handleIncomingRpcResponseFailure(
+        requestId,
+        new RpcError(errorCode, errorMessage),
+      );
+
+      await expect(completionPromise).rejects.toThrow(errorMessage);
+    });
+
+    it('should handle participant disconnection during v2 RPC request', async () => {
+      const [, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'remote-identity',
+        method: 'disconnectMethod',
+        payload: 'disconnectPayload',
+      });
+
+      rpcClientManager.handleParticipantDisconnected('remote-identity');
+
+      await expect(completionPromise).rejects.toThrow('Recipient disconnected');
+    });
+
+    it('should send V2 RPC request and ensure that a non matching response does not complete the RPC', async () => {
+      // Step 1: send an example rpc request
+      const [, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'destination-identity',
+        method: 'test-method',
+        payload: 'test payload',
+      });
+
+      // Step 2: send an acknowledgement / response for a different rpc
+      rpcClientManager.handleIncomingRpcAck('bogus request id');
+      await rpcClientManager.handleIncomingDataStream(
+        mockTextStreamReader('response-payload'),
+        'destination-identity',
+        { [RpcRequestAttrs.RPC_REQUEST_ID]: 'bogus request id' },
+      );
+
+      // Step 3: Make sure that the completion promise didn't resolve.
+      await expect(
+        Promise.race([completionPromise, Promise.resolve('still pending')]),
+      ).resolves.toStrictEqual('still pending');
+    });
+
+    it('should ensure that many rpc requests generate different request ids', async () => {
+      const requestIds: Array<string> = [];
+      for (let i = 0; i < 5; i += 1) {
+        const [requestId] = await rpcClientManager.performRpc({
+          destinationIdentity: 'destination-identity',
+          method: 'test-method',
+          payload: 'test payload',
+        });
+        requestIds.push(requestId);
+      }
+
+      // Make sure all request ids are unique
+      for (let i = 0; i < requestIds.length; i += 1) {
+        for (let j = 0; j < requestIds.length; j += 1) {
+          if (i === j) {
+            continue;
+          }
+          expect(requestIds[i]).not.toStrictEqual(requestIds[j]);
+        }
+      }
+    });
+
+    it('should not drop ack and response that arrive before publish completes', async () => {
+      // Hold the publish path open by blocking writer.close() until we explicitly resolve it.
+      let resolveClose!: () => void;
+      const closeBlocked = new Promise<void>((resolve) => {
+        resolveClose = resolve;
+      });
+      mockStreamTextWriter.close = vi.fn().mockReturnValue(closeBlocked);
+
+      // Start performRpc but don't await its return yet. The synchronous prefix runs streamText.
+      const performRpcPromise = rpcClientManager.performRpc({
+        destinationIdentity: 'destination-identity',
+        method: 'test-method',
+        payload: 'request-payload',
+        responseTimeout: 200,
+      });
+
+      // streamText was called synchronously; pull the request id out of the attributes.
+      const streamTextCalls = (mockOutgoingDataStreamManager.streamText as ReturnType<typeof vi.fn>)
+        .mock.calls;
+      expect(streamTextCalls.length).toBe(1);
+      const requestId = streamTextCalls[0][0].attributes[RpcRequestAttrs.RPC_REQUEST_ID];
+
+      // Deliver ack and response BEFORE close() unblocks - the publish has not yet returned.
+      rpcClientManager.handleIncomingRpcAck(requestId);
+      await rpcClientManager.handleIncomingDataStream(
+        mockTextStreamReader('response-payload'),
+        'destination-identity',
+        { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+      );
+
+      // Now allow the publish path to complete.
+      resolveClose();
+
+      const [, completionPromise] = await performRpcPromise;
+      await expect(completionPromise).resolves.toStrictEqual('response-payload');
+    });
+
+    it('should ignore a late ack and response that arrive after ack-timeout fires', async () => {
+      vi.useFakeTimers();
+
+      try {
+        const [requestId, completionPromise] = await rpcClientManager.performRpc({
+          destinationIdentity: 'remote-identity',
+          method: 'test-method',
+          payload: 'test-payload',
+        });
+
+        // Register the rejection handler before advancing so the rejection is caught.
+        const rejectPromise = expect(completionPromise).rejects.toThrow(/Connection timeout/i);
+
+        // Advance past the ack-timeout window (maxRoundTripLatencyMs = 7000ms).
+        await vi.advanceTimersByTimeAsync(7001);
+
+        await rejectPromise;
+
+        // A delayed ack and response now arrive for the same request id - should be silently
+        // ignored: no throw, no second resolution, no unhandled rejection.
+        expect(() => rpcClientManager.handleIncomingRpcAck(requestId)).not.toThrow();
+        await rpcClientManager.handleIncomingDataStream(
+          mockTextStreamReader('late response'),
+          'remote-identity',
+          { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+        );
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it('should not resolve a v2 response stream that comes from a wrong sender identity', async () => {
+      const [requestId, completionPromise] = await rpcClientManager.performRpc({
+        destinationIdentity: 'alice',
+        method: 'test-method',
+        payload: 'test payload',
+      });
+
+      rpcClientManager.handleIncomingRpcAck(requestId);
+
+      // Simulate a v2 response data stream that arrived purportedly from "mallory" rather
+      // than the destination identity "alice".
+      await rpcClientManager.handleIncomingDataStream(
+        mockTextStreamReader('malicious response'),
+        'mallory',
+        { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+      );
+
+      // The completionPromise must remain pending - the wrong-sender response is ignored.
+      await expect(
+        Promise.race([completionPromise, Promise.resolve('still pending')]),
+      ).resolves.toStrictEqual('still pending');
+    });
+  });
+});

package/src/room/rpc/client/RpcClientManager.ts

@@ -0,0 +1,269 @@
+import { DataPacket, DataPacket_Kind, RpcRequest } from '@livekit/protocol';
+import EventEmitter from 'events';
+import type TypedEmitter from 'typed-emitter';
+import { type StructuredLogger } from '../../../logger';
+import { CLIENT_PROTOCOL_DATA_STREAM_RPC } from '../../../version';
+import { type TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import { Future, compareVersions } from '../../utils';
+import {
+  MAX_V1_PAYLOAD_BYTES,
+  type PerformRpcParams,
+  RPC_REQUEST_DATA_STREAM_TOPIC,
+  RPC_VERSION_V1,
+  RPC_VERSION_V2,
+  RpcError,
+  RpcRequestAttrs,
+  byteLength,
+} from '../utils';
+import type { RpcClientManagerCallbacks } from './events';
+
+/**
+ * Manages the client (caller) side of RPC: sending requests, tracking pending
+ * ack/response state, and handling incoming ack/response packets.
+ * @internal
+ */
+export default class RpcClientManager extends (EventEmitter as new () => TypedEmitter<RpcClientManagerCallbacks>) {
+  private log: StructuredLogger;
+
+  private outgoingDataStreamManager: OutgoingDataStreamManager;
+
+  private getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number;
+
+  private getServerVersion: () => string | undefined;
+
+  private pendingAcks = new Map<string, { resolve: () => void; participantIdentity: string }>();
+
+  private pendingResponses = new Map<
+    string /* request id */,
+    {
+      completionFuture: Future<string, RpcError>;
+      participantIdentity: string;
+    }
+  >();
+
+  constructor(
+    log: StructuredLogger,
+    outgoingDataStreamManager: OutgoingDataStreamManager,
+    getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number,
+    getServerVersion: () => string | undefined,
+  ) {
+    super();
+    this.log = log;
+    this.outgoingDataStreamManager = outgoingDataStreamManager;
+    this.getRemoteParticipantClientProtocol = getRemoteParticipantClientProtocol;
+    this.getServerVersion = getServerVersion;
+  }
+
+  async performRpc({
+    destinationIdentity,
+    method,
+    payload,
+    responseTimeout: responseTimeoutMs = 15000,
+  }: PerformRpcParams): Promise<[id: string, completionPromise: Promise<string>]> {
+    const maxRoundTripLatencyMs = 7000;
+    const minEffectiveTimeoutMs = maxRoundTripLatencyMs + 1000;
+
+    const remoteClientProtocol = this.getRemoteParticipantClientProtocol(destinationIdentity);
+    const payloadBytes = byteLength(payload);
+
+    // Only enforce the legacy size limit when on rpc v1
+    if (
+      payloadBytes > MAX_V1_PAYLOAD_BYTES &&
+      remoteClientProtocol < CLIENT_PROTOCOL_DATA_STREAM_RPC
+    ) {
+      throw RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE');
+    }
+
+    const serverVersion = this.getServerVersion();
+    if (serverVersion && compareVersions(serverVersion, '1.8.0') < 0) {
+      throw RpcError.builtIn('UNSUPPORTED_SERVER');
+    }
+
+    const effectiveTimeoutMs = Math.max(responseTimeoutMs, minEffectiveTimeoutMs);
+    const id = crypto.randomUUID();
+
+    const completionFuture = new Future<string, RpcError>();
+
+    const ackTimeoutId = setTimeout(() => {
+      this.pendingAcks.delete(id);
+      completionFuture.reject?.(RpcError.builtIn('CONNECTION_TIMEOUT'));
+      this.pendingResponses.delete(id);
+      clearTimeout(responseTimeoutId);
+    }, maxRoundTripLatencyMs);
+
+    this.pendingAcks.set(id, {
+      resolve: () => {
+        clearTimeout(ackTimeoutId);
+      },
+      participantIdentity: destinationIdentity,
+    });
+
+    this.pendingResponses.set(id, {
+      completionFuture,
+      participantIdentity: destinationIdentity,
+    });
+
+    await this.publishRpcRequest(
+      destinationIdentity,
+      id,
+      method,
+      payload,
+      effectiveTimeoutMs,
+      remoteClientProtocol,
+    );
+
+    const responseTimeoutId = setTimeout(() => {
+      this.pendingResponses.delete(id);
+      completionFuture.reject?.(RpcError.builtIn('RESPONSE_TIMEOUT'));
+    }, responseTimeoutMs);
+
+    const completionPromise = completionFuture.promise.finally(() => {
+      clearTimeout(responseTimeoutId);
+
+      if (this.pendingAcks.has(id)) {
+        this.log.warn('RPC response received before ack', id);
+        this.pendingAcks.delete(id);
+        clearTimeout(ackTimeoutId);
+      }
+    });
+
+    return [id, completionPromise];
+  }
+
+  private async publishRpcRequest(
+    destinationIdentity: string,
+    requestId: string,
+    method: string,
+    payload: string,
+    responseTimeout: number,
+    remoteClientProtocol: number,
+  ) {
+    if (remoteClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
+      // Send payload as a data stream - a "version 2" rpc request.
+      const writer = await this.outgoingDataStreamManager.streamText({
+        topic: RPC_REQUEST_DATA_STREAM_TOPIC,
+        destinationIdentities: [destinationIdentity],
+        attributes: {
+          [RpcRequestAttrs.RPC_REQUEST_ID]: requestId,
+          [RpcRequestAttrs.RPC_REQUEST_METHOD]: method,
+          [RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS]: `${responseTimeout}`,
+          [RpcRequestAttrs.RPC_REQUEST_VERSION]: `${RPC_VERSION_V2}`,
+        },
+      });
+
+      await writer.write(payload);
+      await writer.close();
+      return;
+    }
+
+    // Fallback to sending a literal RpcRequest - a "version 1" rpc request.
+    this.emit('sendDataPacket', {
+      packet: new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcRequest',
+          value: new RpcRequest({
+            id: requestId,
+            method,
+            payload,
+            responseTimeoutMs: responseTimeout,
+            version: RPC_VERSION_V1,
+          }),
+        },
+      }),
+    });
+  }
+
+  /**
+   * Handle an incoming data stream containing an RPC response payload.
+   * @internal
+   */
+  async handleIncomingDataStream(
+    reader: TextStreamReader,
+    senderIdentity: Participant['identity'],
+    attributes: Record<string, string>,
+  ) {
+    const associatedRequestId = attributes[RpcRequestAttrs.RPC_REQUEST_ID];
+    if (!associatedRequestId) {
+      this.log.warn(`RPC data stream malformed: ${RpcRequestAttrs.RPC_REQUEST_ID} not set.`);
+      // NOTE: no response can be sent here, because there's no request id so associate
+      // so logging is the best we can do here.
+      return;
+    }
+
+    const pending = this.pendingResponses.get(associatedRequestId);
+    if (pending && pending.participantIdentity !== senderIdentity) {
+      this.log.warn(
+        `RPC response stream for ${associatedRequestId} arrived from unexpected sender ${senderIdentity}, expected ${pending.participantIdentity}. Ignoring.`,
+      );
+      return;
+    }
+
+    let payload: string;
+    try {
+      payload = await reader.readAll();
+    } catch (e) {
+      this.log.warn(`Error reading RPC response payload: ${e}`);
+      this.handleIncomingRpcResponseFailure(
+        associatedRequestId,
+        RpcError.builtIn('APPLICATION_ERROR', 'Error reading RPC response payload', { cause: e }),
+      );
+      return;
+    }
+
+    this.handleIncomingRpcResponseSuccess(associatedRequestId, payload);
+  }
+
+  /** @internal */
+  handleIncomingRpcResponseSuccess(requestId: string, payload: string) {
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      handler.completionFuture.resolve?.(payload);
+      this.pendingResponses.delete(requestId);
+    } else {
+      this.log.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+
+  /** @internal */
+  handleIncomingRpcResponseFailure(requestId: string, error: RpcError) {
+    const handler = this.pendingResponses.get(requestId);
+    if (handler) {
+      handler.completionFuture.reject?.(error);
+      this.pendingResponses.delete(requestId);
+    } else {
+      this.log.error('Response received for unexpected RPC request', requestId);
+    }
+  }
+
+  /** @internal */
+  handleIncomingRpcAck(requestId: string) {
+    const handler = this.pendingAcks.get(requestId);
+    if (handler) {
+      handler.resolve();
+      this.pendingAcks.delete(requestId);
+    } else {
+      this.log.error(`Ack received for unexpected RPC request: ${requestId}`);
+    }
+  }
+
+  /** @internal */
+  handleParticipantDisconnected(participantIdentity: string) {
+    for (const [id, { participantIdentity: pendingIdentity }] of this.pendingAcks) {
+      if (pendingIdentity === participantIdentity) {
+        this.pendingAcks.delete(id);
+      }
+    }
+
+    for (const [id, { participantIdentity: pendingIdentity, completionFuture }] of this
+      .pendingResponses) {
+      if (pendingIdentity === participantIdentity) {
+        completionFuture.reject?.(RpcError.builtIn('RECIPIENT_DISCONNECTED'));
+        this.pendingResponses.delete(id);
+      }
+    }
+  }
+}