diff --git a/.changeset/beige-brooms-add.md b/.changeset/beige-brooms-add.md
new file mode 100644
index 0000000000..2d49e1c07c
--- /dev/null
+++ b/.changeset/beige-brooms-add.md
@@ -0,0 +1,5 @@
+---
+"livekit-client": minor
+---
+
+RPC implementation
diff --git a/.gitignore b/.gitignore
index e2c8972cdb..fa07350e35 100644
--- a/.gitignore
+++ b/.gitignore
@@ -112,3 +112,5 @@ docs/
pkg/
bin/
examples/**/build/
+
+.env.local
\ No newline at end of file
diff --git a/README.md b/README.md
index 3c051cc7b8..d161e0ea44 100644
--- a/README.md
+++ b/README.md
@@ -304,12 +304,66 @@ setLogExtension((level: LogLevel, msg: string, context: object) => {
});
```
+### RPC
+
+Perform your own predefined method calls from one participant to another.
+
+This feature is especially powerful when used with [Agents](https://docs.livekit.io/agents), for instance to forward LLM function calls to your client application.
+
+#### Registering an RPC method
+
+The participant who implements the method and will receive its calls must first register support:
+
+```typescript
+room.localParticipant?.registerRpcMethod(
+ // method name - can be any string that makes sense for your application
+ 'greet',
+
+ // method handler - will be called when the method is invoked by a RemoteParticipant
+ async (requestId: string, callerIdentity: string, payload: string, responseTimeoutMs: number) => {
+ console.log(`Received greeting from ${callerIdentity}: ${payload}`);
+ return `Hello, ${callerIdentity}!`;
+ }
+);
+```
+
+In addition to the payload, your handler will also receive `responseTimeoutMs`, which informs you the maximum time available to return a response. If you are unable to respond in time, the call will result in an error on the caller's side.
+
+#### Performing an RPC request
+
+The caller may then initiate an RPC call like so:
+
+```typescript
+try {
+ const response = await room.localParticipant!.performRpc(
+ 'recipient-identity',
+ 'greet',
+ 'Hello from RPC!'
+ );
+ console.log('RPC response:', response);
+} catch (error) {
+ console.error('RPC call failed:', error);
+}
+```
+
+You may find it useful to adjust the `responseTimeoutMs` parameter, which indicates the amount of time you will wait for a response. We recommend keeping this value as low as possible while still satisfying the constraints of your application.
+
+#### Errors
+
+LiveKit is a dynamic realtime environment and calls can fail for various reasons.
+
+You may throw errors of the type `RpcError` with a string `message` in an RPC method handler and they will be received on the caller's side with the message intact. Other errors will not be transmitted and will instead arrive to the caller as `1500` ("Application Error"). Other built-in errors are detailed in `RpcError`.
+
## Examples
### Demo App
[examples/demo](examples/demo/) contains a demo webapp that uses the SDK. Run it with `pnpm install && pnpm examples:demo`
+### RPC Demo
+
+[examples/rpc](examples/rpc/) contains a demo webapp that uses the SDK to showcase the RPC capabilities. Run it with `pnpm install && pnpm dev` from the `examples/rpc` directory.
+
## Browser Support
| Browser | Desktop OS | Mobile OS |
diff --git a/examples/demo/tsconfig.json b/examples/demo/tsconfig.json
index 0c15fdd693..4d3333f991 100644
--- a/examples/demo/tsconfig.json
+++ b/examples/demo/tsconfig.json
@@ -1,5 +1,5 @@
{
- "extends": "../../tsconfig",
+ "extends": "../../tsconfig.json",
"compilerOptions": {
"target": "ESNext" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
"module": "ESNext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
diff --git a/examples/rpc/README.md b/examples/rpc/README.md
new file mode 100644
index 0000000000..a90faa4b49
--- /dev/null
+++ b/examples/rpc/README.md
@@ -0,0 +1,13 @@
+# RPC Demo
+
+A working multi-participant live demo of the LiveKit RPC feature.
+
+## Running the Demo
+
+1. Create `.env.local` with `LIVEKIT_API_KEY`, `LIVEKIT_API_SECRET`, and `LIVEKIT_URL`
+1. Install dependencies: `pnpm install`
+2. Start server: `pnpm dev`
+3. Open browser to local URL (typically http://localhost:5173)
+4. Press the button to watch the demo run
+
+For more detailed information on using RPC with LiveKit, refer to the [main README](../../README.md#rpc).
diff --git a/examples/rpc/api.ts b/examples/rpc/api.ts
new file mode 100644
index 0000000000..eeb6dab6fa
--- /dev/null
+++ b/examples/rpc/api.ts
@@ -0,0 +1,39 @@
+import dotenv from 'dotenv';
+import express from 'express';
+import type { Express } from 'express';
+import { AccessToken } from 'livekit-server-sdk';
+
+dotenv.config({ path: '.env.local' });
+
+const LIVEKIT_API_KEY = process.env.LIVEKIT_API_KEY;
+const LIVEKIT_API_SECRET = process.env.LIVEKIT_API_SECRET;
+const LIVEKIT_URL = process.env.LIVEKIT_URL;
+
+const app = express();
+app.use(express.json());
+
+app.post('/api/get-token', async (req, res) => {
+ const { identity, roomName } = req.body;
+
+ if (!LIVEKIT_API_KEY || !LIVEKIT_API_SECRET) {
+ res.status(500).json({ error: 'Server misconfigured' });
+ return;
+ }
+
+ const token = new AccessToken(LIVEKIT_API_KEY, LIVEKIT_API_SECRET, {
+ identity,
+ });
+ token.addGrant({
+ room: roomName,
+ roomJoin: true,
+ canPublish: true,
+ canSubscribe: true,
+ });
+
+ res.json({
+ token: await token.toJwt(),
+ url: LIVEKIT_URL,
+ });
+});
+
+export const handler: Express = app;
diff --git a/examples/rpc/index.html b/examples/rpc/index.html
new file mode 100644
index 0000000000..1b8cbc4573
--- /dev/null
+++ b/examples/rpc/index.html
@@ -0,0 +1,19 @@
+
+
+
+ LiveKit RPC Demo
+
+
LiveKit RPC Demo
+
+
+
+
Run Demo
+
((resolve) => setTimeout(resolve, 2000)))
+ .then(() => performQuantumHypergeometricSeries(callersRoom)),
+ ]);
+ } catch (error) {
+ console.error('Error:', error);
+ }
+
+ try {
+ console.log('\n\nRunning disconnection example...');
+ const disconnectionAfterPromise = disconnectAfter(greetersRoom, 1000);
+ const disconnectionRpcPromise = performDisconnection(callersRoom);
+
+ await Promise.all([disconnectionAfterPromise, disconnectionRpcPromise]);
+ } catch (error) {
+ console.error('Unexpected error:', error);
+ }
+
+ console.log('participants done, disconnecting');
+ await Promise.all([
+ callersRoom.disconnect(),
+ greetersRoom.disconnect(),
+ mathGeniusRoom.disconnect(),
+ ]);
+
+ console.log('\n\nParticipants disconnected. Example completed.');
+}
+
+const registerReceiverMethods = async (greetersRoom: Room, mathGeniusRoom: Room): Promise => {
+ await greetersRoom.localParticipant?.registerRpcMethod(
+ 'arrival',
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ async (
+ requestId: string,
+ callerIdentity: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) => {
+ console.log(`[Greeter] Oh ${callerIdentity} arrived and said "${payload}"`);
+ await new Promise((resolve) => setTimeout(resolve, 2000));
+ return 'Welcome and have a wonderful day!';
+ },
+ );
+
+ await mathGeniusRoom.localParticipant?.registerRpcMethod(
+ 'square-root',
+ async (
+ requestId: string,
+ callerIdentity: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) => {
+ const jsonData = JSON.parse(payload);
+ const number = jsonData.number;
+ console.log(
+ `[Math Genius] I guess ${callerIdentity} wants the square root of ${number}. I've only got ${responseTimeoutMs / 1000} seconds to respond but I think I can pull it off.`,
+ );
+
+ console.log(`[Math Genius] *doing math*…`);
+ await new Promise((resolve) => setTimeout(resolve, 2000));
+
+ const result = Math.sqrt(number);
+ console.log(`[Math Genius] Aha! It's ${result}`);
+ return JSON.stringify({ result });
+ },
+ );
+
+ await mathGeniusRoom.localParticipant?.registerRpcMethod(
+ 'divide',
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ async (
+ requestId: string,
+ callerIdentity: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) => {
+ const jsonData = JSON.parse(payload);
+ const { numerator, denominator } = jsonData;
+
+ console.log(
+ `[Math Genius] ${callerIdentity} wants to divide ${numerator} by ${denominator}. Let me think...`,
+ );
+
+ await new Promise((resolve) => setTimeout(resolve, 2000));
+
+ if (denominator === 0) {
+ throw new Error('Cannot divide by zero');
+ }
+
+ const result = numerator / denominator;
+ console.log(`[Math Genius] ${numerator} / ${denominator} = ${result}`);
+ return JSON.stringify({ result });
+ },
+ );
+};
+
+const performGreeting = async (room: Room): Promise => {
+ console.log("[Caller] Letting the greeter know that I've arrived");
+ try {
+ const response = await room.localParticipant!.performRpc('greeter', 'arrival', 'Hello');
+ console.log(`[Caller] That's nice, the greeter said: "${response}"`);
+ } catch (error) {
+ console.error('[Caller] RPC call failed:', error);
+ throw error;
+ }
+};
+
+const performDisconnection = async (room: Room): Promise => {
+ console.log('[Caller] Checking back in on the greeter...');
+ try {
+ const response = await room.localParticipant!.performRpc(
+ 'greeter',
+ 'arrival',
+ 'You still there?',
+ );
+ console.log(`[Caller] That's nice, the greeter said: "${response}"`);
+ } catch (error) {
+ if (error instanceof RpcError && error.code === RpcError.ErrorCode.RECIPIENT_DISCONNECTED) {
+ console.log('[Caller] The greeter disconnected during the request.');
+ } else {
+ console.error('[Caller] Unexpected error:', error);
+ throw error;
+ }
+ }
+};
+
+const performSquareRoot = async (room: Room): Promise => {
+ console.log("[Caller] What's the square root of 16?");
+ try {
+ const response = await room.localParticipant!.performRpc(
+ 'math-genius',
+ 'square-root',
+ JSON.stringify({ number: 16 }),
+ );
+ const parsedResponse = JSON.parse(response);
+ console.log(`[Caller] Nice, the answer was ${parsedResponse.result}`);
+ } catch (error) {
+ console.error('[Caller] RPC call failed:', error);
+ throw error;
+ }
+};
+
+const performQuantumHypergeometricSeries = async (room: Room): Promise => {
+ console.log("[Caller] What's the quantum hypergeometric series of 42?");
+ try {
+ const response = await room.localParticipant!.performRpc(
+ 'math-genius',
+ 'quantum-hypergeometric-series',
+ JSON.stringify({ number: 42 }),
+ );
+ const parsedResponse = JSON.parse(response);
+ console.log(`[Caller] genius says ${parsedResponse.result}!`);
+ } catch (error) {
+ if (error instanceof RpcError) {
+ if (error.code === RpcError.ErrorCode.UNSUPPORTED_METHOD) {
+ console.log(`[Caller] Aww looks like the genius doesn't know that one.`);
+ return;
+ }
+ }
+
+ console.error('[Caller] Unexpected error:', error);
+ throw error;
+ }
+};
+
+const performDivision = async (room: Room): Promise => {
+ console.log("[Caller] Let's try dividing 10 by 0");
+ try {
+ const response = await room.localParticipant!.performRpc(
+ 'math-genius',
+ 'divide',
+ JSON.stringify({ numerator: 10, denominator: 0 }),
+ );
+ const parsedResponse = JSON.parse(response);
+ console.log(`[Caller] The result is ${parsedResponse.result}`);
+ } catch (error) {
+ if (error instanceof RpcError) {
+ if (error.code === RpcError.ErrorCode.APPLICATION_ERROR) {
+ console.log(`[Caller] Oops! I guess that didn't work. Let's try something else.`);
+ } else {
+ console.error('[Caller] Unexpected RPC error:', error);
+ }
+ } else {
+ console.error('[Caller] Unexpected error:', error);
+ }
+ }
+};
+const connectParticipant = async (identity: string, roomName: string): Promise => {
+ const room = new Room();
+ const { token, url } = await fetchToken(identity, roomName);
+
+ room.on(RoomEvent.Disconnected, () => {
+ console.log(`[${identity}] Disconnected from room`);
+ });
+
+ await room.connect(url, token, {
+ autoSubscribe: true,
+ } as RoomConnectOptions);
+
+ await new Promise((resolve) => {
+ if (room.state === 'connected') {
+ resolve();
+ } else {
+ room.once(RoomEvent.Connected, () => resolve());
+ }
+ });
+
+ console.log(`${identity} connected.`);
+
+ return room;
+};
+
+const fetchToken = async (
+ identity: string,
+ roomName: string,
+): Promise<{ token: string; url: string }> => {
+ const response = await fetch('/api/get-token', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({ identity, roomName }),
+ });
+
+ if (!response.ok) {
+ throw new Error('Failed to fetch token');
+ }
+
+ const data = await response.json();
+ return { token: data.token, url: data.url };
+};
+
+(window as any).runRpcDemo = main;
+
+const logToUI = (message: string) => {
+ const logArea = document.getElementById('log') as HTMLTextAreaElement;
+ logArea.value += message + '\n';
+ logArea.scrollTop = logArea.scrollHeight;
+};
+
+const originalConsoleLog = console.log;
+console.log = (...args) => {
+ const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(3);
+ const formattedMessage = `[+${elapsedTime}s] ${args.join(' ')}`;
+ originalConsoleLog.apply(console, [formattedMessage]);
+ logToUI(formattedMessage);
+};
+
+const originalConsoleError = console.error;
+console.error = (...args) => {
+ const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(3);
+ const formattedMessage = `[+${elapsedTime}s] ERROR: ${args.join(' ')}`;
+ originalConsoleError.apply(console, [formattedMessage]);
+ logToUI(formattedMessage);
+};
+
+document.addEventListener('DOMContentLoaded', () => {
+ const runDemoButton = document.getElementById('run-demo') as HTMLButtonElement;
+ if (runDemoButton) {
+ runDemoButton.addEventListener('click', async () => {
+ runDemoButton.disabled = true;
+ await (window as any).runRpcDemo();
+ runDemoButton.disabled = false;
+ });
+ }
+});
+
+const disconnectAfter = async (room: Room, delay: number): Promise => {
+ await new Promise((resolve) => setTimeout(resolve, delay));
+ await room.disconnect();
+};
diff --git a/examples/rpc/styles.css b/examples/rpc/styles.css
new file mode 100644
index 0000000000..0c9d96af85
--- /dev/null
+++ b/examples/rpc/styles.css
@@ -0,0 +1,77 @@
+body {
+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+ background-color: #f0f2f5;
+ color: #333;
+ line-height: 1.6;
+ margin: 0;
+ padding: 0;
+}
+
+.container {
+ max-width: 800px;
+ margin: 40px auto;
+ padding: 30px;
+ background-color: #ffffff;
+ box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+ border-radius: 12px;
+}
+
+h1 {
+ text-align: center;
+ color: #2c3e50;
+ margin-bottom: 30px;
+ font-weight: 600;
+}
+
+#log-area {
+ margin-top: 20px;
+ margin-bottom: 20px;
+}
+
+#log {
+ box-sizing: border-box;
+ width: 100%;
+ height: 300px;
+ padding: 10px;
+ border: 1px solid #ddd;
+ border-radius: 4px;
+ font-family: monospace;
+ font-size: 14px;
+ resize: vertical;
+}
+
+.btn {
+ display: block;
+ width: 200px;
+ padding: 10px 20px;
+ background-color: #3498db;
+ color: white;
+ border: none;
+ border-radius: 5px;
+ font-size: 16px;
+ cursor: pointer;
+ transition: background-color 0.3s, transform 0.1s;
+ margin: 0 auto;
+ font-weight: 500;
+}
+
+.btn:hover {
+ background-color: #2980b9;
+ transform: translateY(-2px);
+}
+
+.btn:active {
+ transform: translateY(0);
+}
+
+.btn:disabled {
+ background-color: #bdc3c7;
+ color: #7f8c8d;
+ cursor: not-allowed;
+ transform: none;
+}
+
+.btn:disabled:hover {
+ background-color: #bdc3c7;
+ transform: none;
+}
diff --git a/examples/rpc/tsconfig.json b/examples/rpc/tsconfig.json
new file mode 100644
index 0000000000..dc6943da35
--- /dev/null
+++ b/examples/rpc/tsconfig.json
@@ -0,0 +1,20 @@
+{
+ "extends": "../../tsconfig.json",
+ "compilerOptions": {
+ "target": "ESNext" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+ "module": "ESNext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+ "outDir": "build",
+ "declaration": true,
+ "declarationMap": true,
+ "sourceMap": true,
+ "strict": true /* Enable all strict type-checking options. */,
+ "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+ "skipLibCheck": true /* Skip type checking of declaration files. */,
+ "noUnusedLocals": true,
+ "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+ "moduleResolution": "node",
+ "resolveJsonModule": true
+ },
+ "include": ["../../src/**/*", "rpc-demo.ts", "api.ts"],
+ "exclude": ["**/*.test.ts", "build/**/*"]
+}
diff --git a/examples/rpc/vite.config.js b/examples/rpc/vite.config.js
new file mode 100644
index 0000000000..9b2f3d7ccd
--- /dev/null
+++ b/examples/rpc/vite.config.js
@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite';
+import mix from 'vite-plugin-mix';
+
+export default defineConfig({
+ plugins: [
+ mix.default({
+ handler: './api.ts',
+ }),
+ ],
+});
\ No newline at end of file
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1d6033c33a..9b0bb66087 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -3276,8 +3276,8 @@ packages:
engines: {node: '>=14.17'}
hasBin: true
- typescript@5.7.0-dev.20241015:
- resolution: {integrity: sha512-nBl/xbQGBZrOmLVFbywn5KVStnsVqGsdjU7jVU+wMAp+bpF0iSrF2ts9pUVFyHdP702zINLxfhlnPr66yXB/ew==}
+ typescript@5.7.0-dev.20241022:
+ resolution: {integrity: sha512-Z8PXMDow1rJGCzBQ9FEeNQHBDEGwqSMAlaM00C9qn/DlUH7DC5dS/pNNEcrQBktPbbIwOjR4XuXYOddJUH2klQ==}
engines: {node: '>=14.17'}
hasBin: true
@@ -5516,7 +5516,7 @@ snapshots:
dependencies:
semver: 7.6.0
shelljs: 0.8.5
- typescript: 5.7.0-dev.20241015
+ typescript: 5.7.0-dev.20241022
electron-to-chromium@1.5.4: {}
@@ -7141,7 +7141,7 @@ snapshots:
typescript@5.6.2: {}
- typescript@5.7.0-dev.20241015: {}
+ typescript@5.7.0-dev.20241022: {}
uc.micro@2.1.0: {}
diff --git a/src/index.ts b/src/index.ts
index a5edc53fee..b96a089830 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -39,6 +39,8 @@ import {
} from './room/utils';
import { getBrowser } from './utils/browserParser';
+export { RpcError } from './room/rpc';
+
export * from './connectionHelper/ConnectionCheck';
export * from './connectionHelper/checks/Checker';
export * from './e2ee';
diff --git a/src/room/Room.ts b/src/room/Room.ts
index 9434af429d..8a0bd97619 100644
--- a/src/room/Room.ts
+++ b/src/room/Room.ts
@@ -1414,6 +1414,7 @@ class Room extends (EventEmitter as new () => TypedEmitter)
participant.unpublishTrack(publication.trackSid, true);
});
this.emit(RoomEvent.ParticipantDisconnected, participant);
+ this.localParticipant?.handleParticipantDisconnected(participant.identity);
}
// updates are sent only when there's a change to speaker ordering
diff --git a/src/room/participant/LocalParticipant.test.ts b/src/room/participant/LocalParticipant.test.ts
new file mode 100644
index 0000000000..a7329a2c65
--- /dev/null
+++ b/src/room/participant/LocalParticipant.test.ts
@@ -0,0 +1,297 @@
+import { DataPacket, DataPacket_Kind } from '@livekit/protocol';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { InternalRoomOptions } from '../../options';
+import type RTCEngine from '../RTCEngine';
+import { RpcError } from '../rpc';
+import LocalParticipant from './LocalParticipant';
+import { ParticipantKind } from './Participant';
+import RemoteParticipant from './RemoteParticipant';
+
+describe('LocalParticipant', () => {
+ describe('registerRpcMethod', () => {
+ let localParticipant: LocalParticipant;
+ let mockEngine: RTCEngine;
+ let mockRoomOptions: InternalRoomOptions;
+ let mockSendDataPacket: ReturnType;
+
+ beforeEach(() => {
+ mockSendDataPacket = vi.fn();
+ mockEngine = {
+ client: {
+ sendUpdateLocalMetadata: vi.fn(),
+ },
+ on: vi.fn().mockReturnThis(),
+ sendDataPacket: mockSendDataPacket,
+ } as unknown as RTCEngine;
+
+ mockRoomOptions = {} as InternalRoomOptions;
+
+ localParticipant = new LocalParticipant(
+ 'test-sid',
+ 'test-identity',
+ mockEngine,
+ mockRoomOptions,
+ );
+ });
+
+ it('should register an RPC method handler', async () => {
+ const methodName = 'testMethod';
+ const handler = vi.fn().mockResolvedValue('test response');
+
+ localParticipant.registerRpcMethod(methodName, handler);
+
+ const mockCaller = new RemoteParticipant(
+ {} as any,
+ 'remote-sid',
+ 'remote-identity',
+ 'Remote Participant',
+ '',
+ undefined,
+ ParticipantKind.STANDARD,
+ );
+
+ await localParticipant.handleIncomingRpcRequest(
+ mockCaller.identity,
+ 'test-request-id',
+ methodName,
+ 'test payload',
+ 5000,
+ );
+
+ expect(handler).toHaveBeenCalledWith(
+ 'test-request-id',
+ mockCaller.identity,
+ 'test payload',
+ 5000,
+ );
+
+ // Check if sendDataPacket was called twice (once for ACK and once for response)
+ expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+ // Check if the first call was for ACK
+ expect(mockSendDataPacket.mock.calls[0][0].value.case).toBe('rpcAck');
+ expect(mockSendDataPacket.mock.calls[0][1]).toBe(DataPacket_Kind.RELIABLE);
+
+ // Check if the second call was for response
+ expect(mockSendDataPacket.mock.calls[1][0].value.case).toBe('rpcResponse');
+ expect(mockSendDataPacket.mock.calls[1][1]).toBe(DataPacket_Kind.RELIABLE);
+ });
+
+ it('should catch and transform unhandled errors in the RPC method handler', async () => {
+ const methodName = 'errorMethod';
+ const errorMessage = 'Test error';
+ const handler = vi.fn().mockRejectedValue(new Error(errorMessage));
+
+ localParticipant.registerRpcMethod(methodName, handler);
+
+ const mockCaller = new RemoteParticipant(
+ {} as any,
+ 'remote-sid',
+ 'remote-identity',
+ 'Remote Participant',
+ '',
+ undefined,
+ ParticipantKind.STANDARD,
+ );
+
+ await localParticipant.handleIncomingRpcRequest(
+ mockCaller.identity,
+ 'test-error-request-id',
+ methodName,
+ 'test payload',
+ 5000,
+ );
+
+ expect(handler).toHaveBeenCalledWith(
+ 'test-error-request-id',
+ mockCaller.identity,
+ 'test payload',
+ 5000,
+ );
+
+ // Check if sendDataPacket was called twice (once for ACK and once for error response)
+ expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+ // Check if the second call was for error response
+ const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+ expect(errorResponse.code).toBe(RpcError.ErrorCode.APPLICATION_ERROR);
+ });
+
+ it('should pass through RpcError thrown by the RPC method handler', async () => {
+ const methodName = 'rpcErrorMethod';
+ const errorCode = 101;
+ const errorMessage = 'some-error-message';
+ const handler = vi.fn().mockRejectedValue(new RpcError(errorCode, errorMessage));
+
+ localParticipant.registerRpcMethod(methodName, handler);
+
+ const mockCaller = new RemoteParticipant(
+ {} as any,
+ 'remote-sid',
+ 'remote-identity',
+ 'Remote Participant',
+ '',
+ undefined,
+ ParticipantKind.STANDARD,
+ );
+
+ await localParticipant.handleIncomingRpcRequest(
+ mockCaller.identity,
+ 'test-rpc-error-request-id',
+ methodName,
+ 'test payload',
+ 5000,
+ );
+
+ expect(handler).toHaveBeenCalledWith(
+ 'test-rpc-error-request-id',
+ mockCaller.identity,
+ 'test payload',
+ 5000,
+ );
+
+ // Check if sendDataPacket was called twice (once for ACK and once for error response)
+ expect(mockSendDataPacket).toHaveBeenCalledTimes(2);
+
+ // Check if the second call was for error response
+ const errorResponse = mockSendDataPacket.mock.calls[1][0].value.value.value.value;
+ expect(errorResponse.code).toBe(errorCode);
+ expect(errorResponse.message).toBe(errorMessage);
+ });
+ });
+
+ describe('performRpc', () => {
+ let localParticipant: LocalParticipant;
+ let mockRemoteParticipant: RemoteParticipant;
+ let mockEngine: RTCEngine;
+ let mockRoomOptions: InternalRoomOptions;
+ let mockSendDataPacket: ReturnType;
+
+ beforeEach(() => {
+ mockSendDataPacket = vi.fn();
+ mockEngine = {
+ client: {
+ sendUpdateLocalMetadata: vi.fn(),
+ },
+ on: vi.fn().mockReturnThis(),
+ sendDataPacket: mockSendDataPacket,
+ } as unknown as RTCEngine;
+
+ mockRoomOptions = {} as InternalRoomOptions;
+
+ localParticipant = new LocalParticipant(
+ 'local-sid',
+ 'local-identity',
+ mockEngine,
+ mockRoomOptions,
+ );
+
+ mockRemoteParticipant = new RemoteParticipant(
+ {} as any,
+ 'remote-sid',
+ 'remote-identity',
+ 'Remote Participant',
+ '',
+ undefined,
+ ParticipantKind.STANDARD,
+ );
+ });
+
+ it('should send RPC request and receive successful response', async () => {
+ const method = 'testMethod';
+ const payload = 'testPayload';
+ const responsePayload = 'responsePayload';
+
+ mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+ const requestId = packet.value.value.id;
+ setTimeout(() => {
+ localParticipant.handleIncomingRpcAck(requestId);
+ setTimeout(() => {
+ localParticipant.handleIncomingRpcResponse(requestId, responsePayload, null);
+ }, 10);
+ }, 10);
+ });
+
+ const result = await localParticipant.performRpc(
+ mockRemoteParticipant.identity,
+ method,
+ payload,
+ );
+
+ expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+ expect(result).toBe(responsePayload);
+ });
+
+ it('should handle RPC request timeout', async () => {
+ const method = 'timeoutMethod';
+ const payload = 'timeoutPayload';
+
+ const timeoutMs = 50;
+
+ const resultPromise = localParticipant.performRpc(
+ mockRemoteParticipant.identity,
+ method,
+ payload,
+ timeoutMs,
+ );
+
+ mockSendDataPacket.mockImplementationOnce(() => {
+ return new Promise((resolve) => {
+ setTimeout(resolve, timeoutMs + 10);
+ });
+ });
+
+ const startTime = Date.now();
+
+ await expect(resultPromise).rejects.toThrow('Response timeout');
+
+ const elapsedTime = Date.now() - startTime;
+ expect(elapsedTime).toBeGreaterThanOrEqual(timeoutMs);
+ expect(elapsedTime).toBeLessThan(timeoutMs + 50); // Allow some margin for test execution
+
+ expect(mockSendDataPacket).toHaveBeenCalledTimes(1);
+ });
+
+ it('should handle RPC error response', async () => {
+ const method = 'errorMethod';
+ const payload = 'errorPayload';
+ const errorCode = 101;
+ const errorMessage = 'Test error message';
+
+ mockSendDataPacket.mockImplementationOnce((packet: DataPacket) => {
+ const requestId = packet.value.value.id;
+ setTimeout(() => {
+ localParticipant.handleIncomingRpcAck(requestId);
+ localParticipant.handleIncomingRpcResponse(
+ requestId,
+ null,
+ new RpcError(errorCode, errorMessage),
+ );
+ }, 10);
+ });
+
+ await expect(
+ localParticipant.performRpc(mockRemoteParticipant.identity, method, payload),
+ ).rejects.toThrow(errorMessage);
+ });
+
+ it('should handle participant disconnection during RPC request', async () => {
+ const method = 'disconnectMethod';
+ const payload = 'disconnectPayload';
+
+ mockSendDataPacket.mockImplementationOnce(() => Promise.resolve());
+
+ const resultPromise = localParticipant.performRpc(
+ mockRemoteParticipant.identity,
+ method,
+ payload,
+ );
+
+ // Simulate a small delay before disconnection
+ await new Promise((resolve) => setTimeout(resolve, 200));
+ localParticipant.handleParticipantDisconnected(mockRemoteParticipant.identity);
+
+ await expect(resultPromise).rejects.toThrow('Recipient disconnected');
+ });
+ });
+});
diff --git a/src/room/participant/LocalParticipant.ts b/src/room/participant/LocalParticipant.ts
index ef7373fd1c..1697561c22 100644
--- a/src/room/participant/LocalParticipant.ts
+++ b/src/room/participant/LocalParticipant.ts
@@ -9,6 +9,9 @@ import {
ParticipantPermission,
RequestResponse,
RequestResponse_Reason,
+ RpcAck,
+ RpcRequest,
+ RpcResponse,
SimulcastCodec,
SipDTMF,
SubscribedQualityUpdate,
@@ -29,6 +32,7 @@ import {
UnexpectedConnectionState,
} from '../errors';
import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
+import { MAX_PAYLOAD_BYTES, RpcError, byteLength } from '../rpc';
import LocalAudioTrack from '../track/LocalAudioTrack';
import LocalTrack from '../track/LocalTrack';
import LocalTrackPublication from '../track/LocalTrackPublication';
@@ -54,6 +58,7 @@ import {
import type { ChatMessage, DataPublishOptions } from '../types';
import {
Future,
+ compareVersions,
isE2EESimulcastSupported,
isFireFox,
isSVCCodec,
@@ -119,6 +124,26 @@ export default class LocalParticipant extends Participant {
private enabledPublishVideoCodecs: Codec[] = [];
+ private rpcHandlers: Map<
+ string,
+ (
+ requestId: string,
+ callerIdentity: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) => Promise
+ > = new Map();
+
+ private pendingAcks = new Map void; participantIdentity: string }>();
+
+ private pendingResponses = new Map<
+ string,
+ {
+ resolve: (payload: string | null, error: RpcError | null) => void;
+ participantIdentity: string;
+ }
+ >();
+
/** @internal */
constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions) {
super(sid, identity, undefined, undefined, {
@@ -187,7 +212,8 @@ export default class LocalParticipant extends Participant {
.on(EngineEvent.LocalTrackUnpublished, this.handleLocalTrackUnpublished)
.on(EngineEvent.SubscribedQualityUpdate, this.handleSubscribedQualityUpdate)
.on(EngineEvent.Disconnected, this.handleDisconnected)
- .on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse);
+ .on(EngineEvent.SignalRequestResponse, this.handleSignalRequestResponse)
+ .on(EngineEvent.DataPacketReceived, this.handleDataPacket);
}
private handleReconnecting = () => {
@@ -221,6 +247,37 @@ export default class LocalParticipant extends Participant {
}
};
+ private handleDataPacket = (packet: DataPacket) => {
+ switch (packet.value.case) {
+ case 'rpcRequest':
+ let rpcRequest = packet.value.value as RpcRequest;
+ this.handleIncomingRpcRequest(
+ packet.participantIdentity,
+ rpcRequest.id,
+ rpcRequest.method,
+ rpcRequest.payload,
+ rpcRequest.responseTimeoutMs,
+ );
+ break;
+ case 'rpcResponse':
+ let rpcResponse = packet.value.value as RpcResponse;
+ let payload: string | null = null;
+ let error: RpcError | null = null;
+
+ if (rpcResponse.value.case === 'payload') {
+ payload = rpcResponse.value.value;
+ } else if (rpcResponse.value.case === 'error') {
+ error = RpcError.fromProto(rpcResponse.value.value);
+ }
+ this.handleIncomingRpcResponse(rpcResponse.requestId, payload, error);
+ break;
+ case 'rpcAck':
+ let rpcAck = packet.value.value as RpcAck;
+ this.handleIncomingRpcAck(rpcAck.requestId);
+ break;
+ }
+ };
+
/**
* Sets and updates the metadata of the local participant.
* Note: this requires `canUpdateOwnMetadata` permission.
@@ -1415,6 +1472,138 @@ export default class LocalParticipant extends Participant {
return msg;
}
+ /**
+ * Initiate an RPC call to a remote participant.
+ * @param destinationIdentity - The `identity` of the destination participant
+ * @param method - The method name to call
+ * @param payload - The method payload
+ * @param responseTimeoutMs - Timeout for receiving a response after initial connection
+ * @returns A promise that resolves with the response payload or rejects with an error.
+ * @throws Error on failure. Details in `message`.
+ */
+ async performRpc(
+ destinationIdentity: string,
+ method: string,
+ payload: string,
+ responseTimeoutMs: number = 10000,
+ ): Promise {
+ const maxRoundTripLatencyMs = 2000;
+
+ return new Promise(async (resolve, reject) => {
+ if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
+ reject(RpcError.builtIn('REQUEST_PAYLOAD_TOO_LARGE'));
+ return;
+ }
+
+ if (
+ this.engine.latestJoinResponse?.serverInfo?.version &&
+ compareVersions(this.engine.latestJoinResponse?.serverInfo?.version, '1.8.0') < 0
+ ) {
+ reject(RpcError.builtIn('UNSUPPORTED_SERVER'));
+ return;
+ }
+
+ const id = crypto.randomUUID();
+ await this.publishRpcRequest(
+ destinationIdentity,
+ id,
+ method,
+ payload,
+ responseTimeoutMs - maxRoundTripLatencyMs,
+ );
+
+ const ackTimeoutId = setTimeout(() => {
+ this.pendingAcks.delete(id);
+ reject(RpcError.builtIn('CONNECTION_TIMEOUT'));
+ this.pendingResponses.delete(id);
+ clearTimeout(responseTimeoutId);
+ }, maxRoundTripLatencyMs);
+
+ this.pendingAcks.set(id, {
+ resolve: () => {
+ clearTimeout(ackTimeoutId);
+ },
+ participantIdentity: destinationIdentity,
+ });
+
+ const responseTimeoutId = setTimeout(() => {
+ this.pendingResponses.delete(id);
+ reject(RpcError.builtIn('RESPONSE_TIMEOUT'));
+ }, responseTimeoutMs);
+
+ this.pendingResponses.set(id, {
+ resolve: (responsePayload: string | null, responseError: RpcError | null) => {
+ clearTimeout(responseTimeoutId);
+ if (this.pendingAcks.has(id)) {
+ console.warn('RPC response received before ack', id);
+ this.pendingAcks.delete(id);
+ clearTimeout(ackTimeoutId);
+ }
+
+ if (responseError) {
+ reject(responseError);
+ } else {
+ resolve(responsePayload ?? '');
+ }
+ },
+ participantIdentity: destinationIdentity,
+ });
+ });
+ }
+
+ /**
+ * Establishes the participant as a receiver for calls of the specified RPC method.
+ * Will overwrite any existing callback for the same method.
+ *
+ * @param method - The name of the indicated RPC method
+ * @param handler - Will be invoked when an RPC request for this method is received
+ * @returns A promise that resolves when the method is successfully registered
+ *
+ * @example
+ * ```typescript
+ * room.localParticipant?.registerRpcMethod(
+ * 'greet',
+ * async (requestId: string, callerIdentity: string, payload: string, responseTimeoutMs: number) => {
+ * console.log(`Received greeting from ${callerIdentity}: ${payload}`);
+ * return `Hello, ${callerIdentity}!`;
+ * }
+ * );
+ * ```
+ *
+ * The handler receives the following parameters:
+ * - `requestId`: A unique identifier for this RPC request
+ * - `callerIdentity`: The identity of the RemoteParticipant who initiated the RPC call
+ * - `payload`: The data sent by the caller (as a string)
+ * - `responseTimeoutMs`: The maximum time available to return a response
+ *
+ * The handler should return a Promise that resolves to a string.
+ * If unable to respond within `responseTimeoutMs`, the request will result in an error on the caller's side.
+ *
+ * You may throw errors of type `RpcError` with a string `message` in the handler,
+ * and they will be received on the caller's side with the message intact.
+ * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+ */
+ registerRpcMethod(
+ method: string,
+ handler: (
+ requestId: string,
+ callerIdentity: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) => Promise,
+ ) {
+ this.rpcHandlers.set(method, handler);
+ }
+
+ /**
+ * Unregisters a previously registered RPC method.
+ *
+ * @param method - The name of the RPC method to unregister
+ */
+ unregisterRpcMethod(method: string) {
+ this.rpcHandlers.delete(method);
+ }
+
/**
* Control who can subscribe to LocalParticipant's published tracks.
*
@@ -1443,6 +1632,157 @@ export default class LocalParticipant extends Participant {
}
}
+ private handleIncomingRpcAck(requestId: string) {
+ const handler = this.pendingAcks.get(requestId);
+ if (handler) {
+ handler.resolve();
+ this.pendingAcks.delete(requestId);
+ } else {
+ console.error('Ack received for unexpected RPC request', requestId);
+ }
+ }
+
+ private handleIncomingRpcResponse(
+ requestId: string,
+ payload: string | null,
+ error: RpcError | null,
+ ) {
+ const handler = this.pendingResponses.get(requestId);
+ if (handler) {
+ handler.resolve(payload, error);
+ this.pendingResponses.delete(requestId);
+ } else {
+ console.error('Response received for unexpected RPC request', requestId);
+ }
+ }
+
+ private async handleIncomingRpcRequest(
+ callerIdentity: string,
+ requestId: string,
+ method: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) {
+ await this.publishRpcAck(callerIdentity, requestId);
+
+ const handler = this.rpcHandlers.get(method);
+
+ if (!handler) {
+ await this.publishRpcResponse(
+ callerIdentity,
+ requestId,
+ null,
+ RpcError.builtIn('UNSUPPORTED_METHOD'),
+ );
+ return;
+ }
+
+ let responseError: RpcError | null = null;
+ let responsePayload: string | null = null;
+
+ try {
+ const response = await handler(requestId, callerIdentity, payload, responseTimeoutMs);
+ if (byteLength(response) > MAX_PAYLOAD_BYTES) {
+ responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
+ console.warn(`RPC Response payload too large for ${method}`);
+ } else {
+ responsePayload = response;
+ }
+ } catch (error) {
+ if (error instanceof RpcError) {
+ responseError = error;
+ } else {
+ console.warn(
+ `Uncaught error returned by RPC handler for ${method}. Returning APPLICATION_ERROR instead.`,
+ error,
+ );
+ responseError = RpcError.builtIn('APPLICATION_ERROR');
+ }
+ }
+ await this.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
+ }
+
+ /** @internal */
+ private async publishRpcRequest(
+ destinationIdentity: string,
+ requestId: string,
+ method: string,
+ payload: string,
+ responseTimeoutMs: number,
+ ) {
+ const packet = new DataPacket({
+ destinationIdentities: [destinationIdentity],
+ kind: DataPacket_Kind.RELIABLE,
+ value: {
+ case: 'rpcRequest',
+ value: new RpcRequest({
+ id: requestId,
+ method,
+ payload,
+ responseTimeoutMs,
+ }),
+ },
+ });
+
+ await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+ }
+
+ /** @internal */
+ private async publishRpcResponse(
+ destinationIdentity: string,
+ requestId: string,
+ payload: string | null,
+ error: RpcError | null,
+ ) {
+ const packet = new DataPacket({
+ destinationIdentities: [destinationIdentity],
+ kind: DataPacket_Kind.RELIABLE,
+ value: {
+ case: 'rpcResponse',
+ value: new RpcResponse({
+ requestId,
+ value: error
+ ? { case: 'error', value: error.toProto() }
+ : { case: 'payload', value: payload ?? '' },
+ }),
+ },
+ });
+
+ await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+ }
+
+ /** @internal */
+ private async publishRpcAck(destinationIdentity: string, requestId: string) {
+ const packet = new DataPacket({
+ destinationIdentities: [destinationIdentity],
+ kind: DataPacket_Kind.RELIABLE,
+ value: {
+ case: 'rpcAck',
+ value: new RpcAck({
+ requestId,
+ }),
+ },
+ });
+
+ await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+ }
+
+ /** @internal */
+ handleParticipantDisconnected(participantIdentity: string) {
+ for (const [id, { participantIdentity: pendingIdentity }] of this.pendingAcks) {
+ if (pendingIdentity === participantIdentity) {
+ this.pendingAcks.delete(id);
+ }
+ }
+
+ for (const [id, { participantIdentity: pendingIdentity, resolve }] of this.pendingResponses) {
+ if (pendingIdentity === participantIdentity) {
+ resolve(null, RpcError.builtIn('RECIPIENT_DISCONNECTED'));
+ this.pendingResponses.delete(id);
+ }
+ }
+ }
+
/** @internal */
setEnabledPublishCodecs(codecs: Codec[]) {
this.enabledPublishVideoCodecs = codecs.filter(
diff --git a/src/room/rpc.ts b/src/room/rpc.ts
new file mode 100644
index 0000000000..437661373b
--- /dev/null
+++ b/src/room/rpc.ts
@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import { RpcError as RpcError_Proto } from '@livekit/protocol';
+
+/**
+ * Specialized error handling for RPC methods.
+ *
+ * Instances of this type, when thrown in a method handler, will have their `message`
+ * serialized and sent across the wire. The sender will receive an equivalent error on the other side.
+ *
+ * Built-in types are included but developers may use any string, with a max length of 256 bytes.
+ */
+
+export class RpcError extends Error {
+ static MAX_MESSAGE_BYTES = 256;
+
+ static MAX_DATA_BYTES = 15360; // 15 KB
+
+ code: number;
+
+ data?: string;
+
+ /**
+ * Creates an error object with the given code and message, plus an optional data payload.
+ *
+ * If thrown in an RPC method handler, the error will be sent back to the caller.
+ *
+ * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
+ */
+ constructor(code: number, message: string, data?: string) {
+ super(message);
+ this.code = code;
+ this.message = truncateBytes(message, RpcError.MAX_MESSAGE_BYTES);
+ this.data = data ? truncateBytes(data, RpcError.MAX_DATA_BYTES) : undefined;
+ }
+
+ /**
+ * @internal
+ */
+ static fromProto(proto: RpcError_Proto) {
+ return new RpcError(proto.code, proto.message, proto.data);
+ }
+
+ /**
+ * @internal
+ */
+ toProto() {
+ return new RpcError_Proto({
+ code: this.code as number,
+ message: this.message,
+ data: this.data,
+ });
+ }
+
+ static ErrorCode = {
+ APPLICATION_ERROR: 1500,
+ CONNECTION_TIMEOUT: 1501,
+ RESPONSE_TIMEOUT: 1502,
+ RECIPIENT_DISCONNECTED: 1503,
+ RESPONSE_PAYLOAD_TOO_LARGE: 1504,
+ SEND_FAILED: 1505,
+
+ UNSUPPORTED_METHOD: 1400,
+ RECIPIENT_NOT_FOUND: 1401,
+ REQUEST_PAYLOAD_TOO_LARGE: 1402,
+ UNSUPPORTED_SERVER: 1403,
+ } as const;
+
+ /**
+ * @internal
+ */
+ static ErrorMessage: Record = {
+ APPLICATION_ERROR: 'Application error in method handler',
+ CONNECTION_TIMEOUT: 'Connection timeout',
+ RESPONSE_TIMEOUT: 'Response timeout',
+ RECIPIENT_DISCONNECTED: 'Recipient disconnected',
+ RESPONSE_PAYLOAD_TOO_LARGE: 'Response payload too large',
+ SEND_FAILED: 'Failed to send',
+
+ UNSUPPORTED_METHOD: 'Method not supported at destination',
+ RECIPIENT_NOT_FOUND: 'Recipient not found',
+ REQUEST_PAYLOAD_TOO_LARGE: 'Request payload too large',
+ UNSUPPORTED_SERVER: 'RPC not supported by server',
+ } as const;
+
+ /**
+ * Creates an error object from the code, with an auto-populated message.
+ *
+ * @internal
+ */
+ static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError {
+ return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data);
+ }
+}
+
+/*
+ * Maximum payload size for RPC requests and responses. If a payload exceeds this size,
+ * the RPC call will fail with a REQUEST_PAYLOAD_TOO_LARGE(1402) or RESPONSE_PAYLOAD_TOO_LARGE(1504) error.
+ */
+export const MAX_PAYLOAD_BYTES = 15360; // 15 KB
+
+/**
+ * @internal
+ */
+export function byteLength(str: string): number {
+ const encoder = new TextEncoder();
+ return encoder.encode(str).length;
+}
+
+/**
+ * @internal
+ */
+export function truncateBytes(str: string, maxBytes: number): string {
+ if (byteLength(str) <= maxBytes) {
+ return str;
+ }
+
+ let low = 0;
+ let high = str.length;
+ const encoder = new TextEncoder();
+
+ while (low < high) {
+ const mid = Math.floor((low + high + 1) / 2);
+ if (encoder.encode(str.slice(0, mid)).length <= maxBytes) {
+ low = mid;
+ } else {
+ high = mid - 1;
+ }
+ }
+
+ return str.slice(0, low);
+}
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
index a7726ac324..c55ea0e2c3 100644
--- a/tsconfig.eslint.json
+++ b/tsconfig.eslint.json
@@ -10,5 +10,5 @@
"rollup.config.worker.js",
"vite.config.mjs"
],
- "exclude": ["dist/**"]
+ "exclude": ["dist/**", "examples/**/dist"]
}
diff --git a/tsconfig.json b/tsconfig.json
index a04ef15eb4..54622bcc39 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -20,7 +20,7 @@
"ignoreDeprecations": "5.0"
},
"exclude": ["dist", "**/*.test.ts"],
- "include": ["src/**/*"],
+ "include": ["src/**/*.ts"],
"typedocOptions": {
"entryPoints": ["src/index.ts"],
"excludeInternal": true,