@whereby.com/assistant-sdk 0.0.0-canary-20250903113745 → 0.0.0-canary-20250908163456

package/dist/index.cjs

@@ -404,7 +404,10 @@ class AudioMixer extends EventEmitter.EventEmitter {
 }
 
 class Assistant extends EventEmitter {
-    constructor({ assistantKey, startCombinedAudioStream } = { startCombinedAudioStream: false }) {
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia } = {
+        startCombinedAudioStream: false,
+        startLocalMedia: false,
+    }) {
         super();
         this.mediaStream = null;
         this.audioSource = null;
@@ -413,10 +416,12 @@ class Assistant extends EventEmitter {
         this.client = new core.WherebyClient();
         this.roomConnection = this.client.getRoomConnection();
         this.localMedia = this.client.getLocalMedia();
-        const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
-        const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
-        this.mediaStream = outputMediaStream;
-        this.audioSource = outputAudioSource;
+        if (startLocalMedia) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
         if (startCombinedAudioStream) {
             const handleStreamReady = () => {
                 if (!this.combinedStream) {
@@ -445,11 +450,21 @@ class Assistant extends EventEmitter {
                 },
                 roomUrl,
                 isNodeSdk: true,
-                roomKey: this.assistantKey,
+                assistantKey: this.assistantKey,
+                isAssistant: true,
             });
             this.roomConnection.joinRoom();
         });
     }
+    startLocalMedia() {
+        if (!this.mediaStream) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
+        this.localMedia.startMedia(this.mediaStream);
+    }
     getLocalMediaStream() {
         return this.mediaStream;
     }
@@ -505,6 +520,9 @@ class Assistant extends EventEmitter {
     subscribeToRemoteParticipants(callback) {
         return this.roomConnection.subscribeToRemoteParticipants(callback);
     }
+    subscribeToChatMessages(callback) {
+        return this.roomConnection.subscribeToChatMessages(callback);
+    }
 }
 
 const BIND_INTERFACE = "en0";
@@ -524,7 +542,7 @@ function buildRoomUrl(roomPath, wherebySubdomain, baseDomain = "whereby.com") {
     return `https://${wherebyDomain}${roomPath}`;
 }
 
-const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
+const webhookRouter = (webhookTriggers, emitter, assistantKey, startCombinedAudioStream = false, startLocalMedia = false) => {
     const router = express.Router();
     const jsonParser = bodyParser.json();
     router.get("/", (_, res) => {
@@ -537,8 +555,8 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
         assert("type" in req.body, "webhook type is required");
         const shouldTriggerOnReceivedWebhook = (_a = webhookTriggers[req.body.type]) === null || _a === void 0 ? void 0 : _a.call(webhookTriggers, req.body);
         if (shouldTriggerOnReceivedWebhook) {
-            const roomUrl = buildRoomUrl(req.body.data.roomName, subdomain);
-            const assistant = new Assistant({ assistantKey, startCombinedAudioStream: true });
+            const roomUrl = buildRoomUrl(req.body.data.roomName, req.body.data.subdomain);
+            const assistant = new Assistant({ assistantKey, startCombinedAudioStream, startLocalMedia });
             assistant.joinRoom(roomUrl);
             emitter.emit(ASSISTANT_JOIN_SUCCESS, { roomUrl, triggerWebhook: req.body, assistant });
         }
@@ -548,16 +566,17 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
     return router;
 };
 class Trigger extends EventEmitter.EventEmitter {
-    constructor({ webhookTriggers = {}, subdomain, port = 4999, assistantKey }) {
+    constructor({ webhookTriggers = {}, port = 4999, assistantKey, startCombinedAudioStream, startLocalMedia, }) {
         super();
         this.webhookTriggers = webhookTriggers;
-        this.subdomain = subdomain;
         this.port = port;
         this.assistantKey = assistantKey;
+        this.startCombinedAudioStream = startCombinedAudioStream !== null && startCombinedAudioStream !== void 0 ? startCombinedAudioStream : false;
+        this.startLocalMedia = startLocalMedia !== null && startLocalMedia !== void 0 ? startLocalMedia : false;
     }
     start() {
         const app = express();
-        const router = webhookRouter(this.webhookTriggers, this.subdomain, this, this.assistantKey);
+        const router = webhookRouter(this.webhookTriggers, this, this.assistantKey, this.startCombinedAudioStream, this.startLocalMedia);
         app.use(router);
         const server = app.listen(this.port, () => {
         });

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { RoomConnectionClient, RemoteParticipantState } from '@whereby.com/core';
+import { RoomConnectionClient, RemoteParticipantState, ChatMessage } from '@whereby.com/core';
 export { RemoteParticipantState } from '@whereby.com/core';
 import wrtc from '@roamhq/wrtc';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
@@ -15,6 +15,7 @@ type AssistantEvents = {
 type AssistantOptions = {
     assistantKey?: string;
     startCombinedAudioStream: boolean;
+    startLocalMedia?: boolean;
 };
 declare class Assistant extends EventEmitter<AssistantEvents> {
     private assistantKey?;
@@ -24,8 +25,9 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     private mediaStream;
     private audioSource;
     private combinedStream;
-    constructor({ assistantKey, startCombinedAudioStream }?: AssistantOptions);
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia }?: AssistantOptions);
     joinRoom(roomUrl: string): Promise<void>;
+    startLocalMedia(): void;
     getLocalMediaStream(): MediaStream | null;
     getLocalAudioSource(): wrtc.nonstandard.RTCAudioSource | null;
     getRoomConnection(): RoomConnectionClient;
@@ -41,6 +43,7 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     acceptWaitingParticipant(participantId: string): void;
     rejectWaitingParticipant(participantId: string): void;
     subscribeToRemoteParticipants(callback: (participants: RemoteParticipantState[]) => void): () => void;
+    subscribeToChatMessages(callback: (messages: ChatMessage[]) => void): () => void;
 }
 
 type WebhookType = "room.client.joined" | "room.client.left" | "room.session.started" | "room.session.ended";
@@ -55,6 +58,7 @@ interface WherebyWebhookInRoom {
     meetingId: string;
     roomName: string;
     roomSessionId: string | null;
+    subdomain: string;
 }
 interface WherebyWebhookDataClient {
     displayName: string;
@@ -100,16 +104,18 @@ type WherebyWebhookTriggers = Partial<{
 
 interface TriggerOptions {
     webhookTriggers: WherebyWebhookTriggers;
-    subdomain: string;
     port?: number;
     assistantKey?: string;
+    startCombinedAudioStream?: boolean;
+    startLocalMedia?: boolean;
 }
 declare class Trigger extends EventEmitter$1<TriggerEvents> {
     private webhookTriggers;
-    private subdomain;
     private port;
     private assistantKey?;
-    constructor({ webhookTriggers, subdomain, port, assistantKey }: TriggerOptions);
+    private startCombinedAudioStream;
+    private startLocalMedia;
+    constructor({ webhookTriggers, port, assistantKey, startCombinedAudioStream, startLocalMedia, }: TriggerOptions);
     start(): void;
 }
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { RoomConnectionClient, RemoteParticipantState } from '@whereby.com/core';
+import { RoomConnectionClient, RemoteParticipantState, ChatMessage } from '@whereby.com/core';
 export { RemoteParticipantState } from '@whereby.com/core';
 import wrtc from '@roamhq/wrtc';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
@@ -15,6 +15,7 @@ type AssistantEvents = {
 type AssistantOptions = {
     assistantKey?: string;
     startCombinedAudioStream: boolean;
+    startLocalMedia?: boolean;
 };
 declare class Assistant extends EventEmitter<AssistantEvents> {
     private assistantKey?;
@@ -24,8 +25,9 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     private mediaStream;
     private audioSource;
     private combinedStream;
-    constructor({ assistantKey, startCombinedAudioStream }?: AssistantOptions);
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia }?: AssistantOptions);
     joinRoom(roomUrl: string): Promise<void>;
+    startLocalMedia(): void;
     getLocalMediaStream(): MediaStream | null;
     getLocalAudioSource(): wrtc.nonstandard.RTCAudioSource | null;
     getRoomConnection(): RoomConnectionClient;
@@ -41,6 +43,7 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     acceptWaitingParticipant(participantId: string): void;
     rejectWaitingParticipant(participantId: string): void;
     subscribeToRemoteParticipants(callback: (participants: RemoteParticipantState[]) => void): () => void;
+    subscribeToChatMessages(callback: (messages: ChatMessage[]) => void): () => void;
 }
 
 type WebhookType = "room.client.joined" | "room.client.left" | "room.session.started" | "room.session.ended";
@@ -55,6 +58,7 @@ interface WherebyWebhookInRoom {
     meetingId: string;
     roomName: string;
     roomSessionId: string | null;
+    subdomain: string;
 }
 interface WherebyWebhookDataClient {
     displayName: string;
@@ -100,16 +104,18 @@ type WherebyWebhookTriggers = Partial<{
 
 interface TriggerOptions {
     webhookTriggers: WherebyWebhookTriggers;
-    subdomain: string;
     port?: number;
     assistantKey?: string;
+    startCombinedAudioStream?: boolean;
+    startLocalMedia?: boolean;
 }
 declare class Trigger extends EventEmitter$1<TriggerEvents> {
     private webhookTriggers;
-    private subdomain;
     private port;
     private assistantKey?;
-    constructor({ webhookTriggers, subdomain, port, assistantKey }: TriggerOptions);
+    private startCombinedAudioStream;
+    private startLocalMedia;
+    constructor({ webhookTriggers, port, assistantKey, startCombinedAudioStream, startLocalMedia, }: TriggerOptions);
     start(): void;
 }
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RoomConnectionClient, RemoteParticipantState } from '@whereby.com/core';
+import { RoomConnectionClient, RemoteParticipantState, ChatMessage } from '@whereby.com/core';
 export { RemoteParticipantState } from '@whereby.com/core';
 import wrtc from '@roamhq/wrtc';
 import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
@@ -15,6 +15,7 @@ type AssistantEvents = {
 type AssistantOptions = {
     assistantKey?: string;
     startCombinedAudioStream: boolean;
+    startLocalMedia?: boolean;
 };
 declare class Assistant extends EventEmitter<AssistantEvents> {
     private assistantKey?;
@@ -24,8 +25,9 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     private mediaStream;
     private audioSource;
     private combinedStream;
-    constructor({ assistantKey, startCombinedAudioStream }?: AssistantOptions);
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia }?: AssistantOptions);
     joinRoom(roomUrl: string): Promise<void>;
+    startLocalMedia(): void;
     getLocalMediaStream(): MediaStream | null;
     getLocalAudioSource(): wrtc.nonstandard.RTCAudioSource | null;
     getRoomConnection(): RoomConnectionClient;
@@ -41,6 +43,7 @@ declare class Assistant extends EventEmitter<AssistantEvents> {
     acceptWaitingParticipant(participantId: string): void;
     rejectWaitingParticipant(participantId: string): void;
     subscribeToRemoteParticipants(callback: (participants: RemoteParticipantState[]) => void): () => void;
+    subscribeToChatMessages(callback: (messages: ChatMessage[]) => void): () => void;
 }
 
 type WebhookType = "room.client.joined" | "room.client.left" | "room.session.started" | "room.session.ended";
@@ -55,6 +58,7 @@ interface WherebyWebhookInRoom {
     meetingId: string;
     roomName: string;
     roomSessionId: string | null;
+    subdomain: string;
 }
 interface WherebyWebhookDataClient {
     displayName: string;
@@ -100,16 +104,18 @@ type WherebyWebhookTriggers = Partial<{
 
 interface TriggerOptions {
     webhookTriggers: WherebyWebhookTriggers;
-    subdomain: string;
     port?: number;
     assistantKey?: string;
+    startCombinedAudioStream?: boolean;
+    startLocalMedia?: boolean;
 }
 declare class Trigger extends EventEmitter$1<TriggerEvents> {
     private webhookTriggers;
-    private subdomain;
     private port;
     private assistantKey?;
-    constructor({ webhookTriggers, subdomain, port, assistantKey }: TriggerOptions);
+    private startCombinedAudioStream;
+    private startLocalMedia;
+    constructor({ webhookTriggers, port, assistantKey, startCombinedAudioStream, startLocalMedia, }: TriggerOptions);
     start(): void;
 }
 

package/dist/index.mjs

@@ -402,7 +402,10 @@ class AudioMixer extends EventEmitter {
 }
 
 class Assistant extends EventEmitter$1 {
-    constructor({ assistantKey, startCombinedAudioStream } = { startCombinedAudioStream: false }) {
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia } = {
+        startCombinedAudioStream: false,
+        startLocalMedia: false,
+    }) {
         super();
         this.mediaStream = null;
         this.audioSource = null;
@@ -411,10 +414,12 @@ class Assistant extends EventEmitter$1 {
         this.client = new WherebyClient();
         this.roomConnection = this.client.getRoomConnection();
         this.localMedia = this.client.getLocalMedia();
-        const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
-        const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
-        this.mediaStream = outputMediaStream;
-        this.audioSource = outputAudioSource;
+        if (startLocalMedia) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
         if (startCombinedAudioStream) {
             const handleStreamReady = () => {
                 if (!this.combinedStream) {
@@ -443,11 +448,21 @@ class Assistant extends EventEmitter$1 {
                 },
                 roomUrl,
                 isNodeSdk: true,
-                roomKey: this.assistantKey,
+                assistantKey: this.assistantKey,
+                isAssistant: true,
             });
             this.roomConnection.joinRoom();
         });
     }
+    startLocalMedia() {
+        if (!this.mediaStream) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
+        this.localMedia.startMedia(this.mediaStream);
+    }
     getLocalMediaStream() {
         return this.mediaStream;
     }
@@ -503,6 +518,9 @@ class Assistant extends EventEmitter$1 {
     subscribeToRemoteParticipants(callback) {
         return this.roomConnection.subscribeToRemoteParticipants(callback);
     }
+    subscribeToChatMessages(callback) {
+        return this.roomConnection.subscribeToChatMessages(callback);
+    }
 }
 
 const BIND_INTERFACE = "en0";
@@ -522,7 +540,7 @@ function buildRoomUrl(roomPath, wherebySubdomain, baseDomain = "whereby.com") {
     return `https://${wherebyDomain}${roomPath}`;
 }
 
-const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
+const webhookRouter = (webhookTriggers, emitter, assistantKey, startCombinedAudioStream = false, startLocalMedia = false) => {
     const router = express.Router();
     const jsonParser = bodyParser.json();
     router.get("/", (_, res) => {
@@ -535,8 +553,8 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
         assert("type" in req.body, "webhook type is required");
         const shouldTriggerOnReceivedWebhook = (_a = webhookTriggers[req.body.type]) === null || _a === void 0 ? void 0 : _a.call(webhookTriggers, req.body);
         if (shouldTriggerOnReceivedWebhook) {
-            const roomUrl = buildRoomUrl(req.body.data.roomName, subdomain);
-            const assistant = new Assistant({ assistantKey, startCombinedAudioStream: true });
+            const roomUrl = buildRoomUrl(req.body.data.roomName, req.body.data.subdomain);
+            const assistant = new Assistant({ assistantKey, startCombinedAudioStream, startLocalMedia });
             assistant.joinRoom(roomUrl);
             emitter.emit(ASSISTANT_JOIN_SUCCESS, { roomUrl, triggerWebhook: req.body, assistant });
         }
@@ -546,16 +564,17 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
     return router;
 };
 class Trigger extends EventEmitter {
-    constructor({ webhookTriggers = {}, subdomain, port = 4999, assistantKey }) {
+    constructor({ webhookTriggers = {}, port = 4999, assistantKey, startCombinedAudioStream, startLocalMedia, }) {
         super();
         this.webhookTriggers = webhookTriggers;
-        this.subdomain = subdomain;
         this.port = port;
         this.assistantKey = assistantKey;
+        this.startCombinedAudioStream = startCombinedAudioStream !== null && startCombinedAudioStream !== void 0 ? startCombinedAudioStream : false;
+        this.startLocalMedia = startLocalMedia !== null && startLocalMedia !== void 0 ? startLocalMedia : false;
     }
     start() {
         const app = express();
-        const router = webhookRouter(this.webhookTriggers, this.subdomain, this, this.assistantKey);
+        const router = webhookRouter(this.webhookTriggers, this, this.assistantKey, this.startCombinedAudioStream, this.startLocalMedia);
         app.use(router);
         const server = app.listen(this.port, () => {
         });

package/dist/legacy-esm.js

@@ -402,7 +402,10 @@ class AudioMixer extends EventEmitter {
 }
 
 class Assistant extends EventEmitter$1 {
-    constructor({ assistantKey, startCombinedAudioStream } = { startCombinedAudioStream: false }) {
+    constructor({ assistantKey, startCombinedAudioStream, startLocalMedia } = {
+        startCombinedAudioStream: false,
+        startLocalMedia: false,
+    }) {
         super();
         this.mediaStream = null;
         this.audioSource = null;
@@ -411,10 +414,12 @@ class Assistant extends EventEmitter$1 {
         this.client = new WherebyClient();
         this.roomConnection = this.client.getRoomConnection();
         this.localMedia = this.client.getLocalMedia();
-        const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
-        const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
-        this.mediaStream = outputMediaStream;
-        this.audioSource = outputAudioSource;
+        if (startLocalMedia) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
         if (startCombinedAudioStream) {
             const handleStreamReady = () => {
                 if (!this.combinedStream) {
@@ -443,11 +448,21 @@ class Assistant extends EventEmitter$1 {
                 },
                 roomUrl,
                 isNodeSdk: true,
-                roomKey: this.assistantKey,
+                assistantKey: this.assistantKey,
+                isAssistant: true,
             });
             this.roomConnection.joinRoom();
         });
     }
+    startLocalMedia() {
+        if (!this.mediaStream) {
+            const outputAudioSource = new wrtc.nonstandard.RTCAudioSource();
+            const outputMediaStream = new wrtc.MediaStream([outputAudioSource.createTrack()]);
+            this.mediaStream = outputMediaStream;
+            this.audioSource = outputAudioSource;
+        }
+        this.localMedia.startMedia(this.mediaStream);
+    }
     getLocalMediaStream() {
         return this.mediaStream;
     }
@@ -503,6 +518,9 @@ class Assistant extends EventEmitter$1 {
     subscribeToRemoteParticipants(callback) {
         return this.roomConnection.subscribeToRemoteParticipants(callback);
     }
+    subscribeToChatMessages(callback) {
+        return this.roomConnection.subscribeToChatMessages(callback);
+    }
 }
 
 const BIND_INTERFACE = "en0";
@@ -522,7 +540,7 @@ function buildRoomUrl(roomPath, wherebySubdomain, baseDomain = "whereby.com") {
     return `https://${wherebyDomain}${roomPath}`;
 }
 
-const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
+const webhookRouter = (webhookTriggers, emitter, assistantKey, startCombinedAudioStream = false, startLocalMedia = false) => {
     const router = express.Router();
     const jsonParser = bodyParser.json();
     router.get("/", (_, res) => {
@@ -535,8 +553,8 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
         assert("type" in req.body, "webhook type is required");
         const shouldTriggerOnReceivedWebhook = (_a = webhookTriggers[req.body.type]) === null || _a === void 0 ? void 0 : _a.call(webhookTriggers, req.body);
         if (shouldTriggerOnReceivedWebhook) {
-            const roomUrl = buildRoomUrl(req.body.data.roomName, subdomain);
-            const assistant = new Assistant({ assistantKey, startCombinedAudioStream: true });
+            const roomUrl = buildRoomUrl(req.body.data.roomName, req.body.data.subdomain);
+            const assistant = new Assistant({ assistantKey, startCombinedAudioStream, startLocalMedia });
             assistant.joinRoom(roomUrl);
             emitter.emit(ASSISTANT_JOIN_SUCCESS, { roomUrl, triggerWebhook: req.body, assistant });
         }
@@ -546,16 +564,17 @@ const webhookRouter = (webhookTriggers, subdomain, emitter, assistantKey) => {
     return router;
 };
 class Trigger extends EventEmitter {
-    constructor({ webhookTriggers = {}, subdomain, port = 4999, assistantKey }) {
+    constructor({ webhookTriggers = {}, port = 4999, assistantKey, startCombinedAudioStream, startLocalMedia, }) {
         super();
         this.webhookTriggers = webhookTriggers;
-        this.subdomain = subdomain;
         this.port = port;
         this.assistantKey = assistantKey;
+        this.startCombinedAudioStream = startCombinedAudioStream !== null && startCombinedAudioStream !== void 0 ? startCombinedAudioStream : false;
+        this.startLocalMedia = startLocalMedia !== null && startLocalMedia !== void 0 ? startLocalMedia : false;
     }
     start() {
         const app = express();
-        const router = webhookRouter(this.webhookTriggers, this.subdomain, this, this.assistantKey);
+        const router = webhookRouter(this.webhookTriggers, this, this.assistantKey, this.startCombinedAudioStream, this.startLocalMedia);
         app.use(router);
         const server = app.listen(this.port, () => {
         });

package/dist/tools.cjs

@@ -0,0 +1,357 @@
+'use strict';
+
+var events = require('events');
+var child_process = require('child_process');
+require('stream');
+var wrtc = require('@roamhq/wrtc');
+
+const { nonstandard: { RTCAudioSink }, } = wrtc;
+class AudioSink extends wrtc.nonstandard.RTCAudioSink {
+    constructor(track) {
+        super(track);
+        this._sink = new RTCAudioSink(track);
+    }
+    subscribe(cb) {
+        this._sink.ondata = cb;
+        return () => {
+            this._sink.ondata = undefined;
+        };
+    }
+}
+
+const PARTICIPANT_SLOTS = 20;
+const STREAM_INPUT_SAMPLE_RATE_IN_HZ = 48000;
+const BYTES_PER_SAMPLE = 2;
+const FRAME_10MS_SAMPLES = 480;
+const slotBuffers = new Map();
+function appendAndDrainTo480(slot, newSamples) {
+    var _a;
+    const prev = (_a = slotBuffers.get(slot)) !== null && _a !== void 0 ? _a : new Int16Array(0);
+    const merged = new Int16Array(prev.length + newSamples.length);
+    merged.set(prev, 0);
+    merged.set(newSamples, prev.length);
+    let offset = 0;
+    while (merged.length - offset >= FRAME_10MS_SAMPLES) {
+        const chunk = merged.subarray(offset, offset + FRAME_10MS_SAMPLES);
+        enqueueFrame(slot, chunk);
+        offset += FRAME_10MS_SAMPLES;
+    }
+    slotBuffers.set(slot, merged.subarray(offset));
+}
+({
+    enqFrames: new Array(PARTICIPANT_SLOTS).fill(0),
+    enqSamples: new Array(PARTICIPANT_SLOTS).fill(0),
+    wroteFrames: new Array(PARTICIPANT_SLOTS).fill(0),
+    wroteSamples: new Array(PARTICIPANT_SLOTS).fill(0),
+    lastFramesSeen: new Array(PARTICIPANT_SLOTS).fill(0),
+});
+let slots = [];
+let stopPacerFn = null;
+let outputPacerState = null;
+function resampleTo48kHz(inputSamples, inputSampleRate, inputFrames) {
+    const ratio = STREAM_INPUT_SAMPLE_RATE_IN_HZ / inputSampleRate;
+    const outputLength = Math.floor(inputFrames * ratio);
+    const output = new Int16Array(outputLength);
+    for (let i = 0; i < outputLength; i++) {
+        const inputIndex = i / ratio;
+        const index = Math.floor(inputIndex);
+        const fraction = inputIndex - index;
+        if (index + 1 < inputSamples.length) {
+            const sample1 = inputSamples[index];
+            const sample2 = inputSamples[index + 1];
+            output[i] = Math.round(sample1 + (sample2 - sample1) * fraction);
+        }
+        else {
+            output[i] = inputSamples[Math.min(index, inputSamples.length - 1)];
+        }
+    }
+    return output;
+}
+function enqueueOutputFrame(samples) {
+    if (outputPacerState) {
+        outputPacerState.frameQueue.push(samples);
+    }
+}
+function startPacer(ff, slotCount, rtcAudioSource, onAudioStreamReady) {
+    if (stopPacerFn) {
+        stopPacerFn();
+        stopPacerFn = null;
+    }
+    const writers = Array.from({ length: slotCount }, (_, i) => ff.stdio[3 + i]);
+    const nowMs = () => Number(process.hrtime.bigint()) / 1e6;
+    const outputFrameMs = (FRAME_10MS_SAMPLES / STREAM_INPUT_SAMPLE_RATE_IN_HZ) * 1000;
+    const t0 = nowMs();
+    slots = Array.from({ length: slotCount }, () => ({
+        q: [],
+        lastFrames: FRAME_10MS_SAMPLES,
+        nextDueMs: t0 + (FRAME_10MS_SAMPLES / STREAM_INPUT_SAMPLE_RATE_IN_HZ) * 1000,
+    }));
+    outputPacerState = {
+        frameQueue: [],
+        nextDueMs: t0 + outputFrameMs,
+        rtcAudioSource,
+        onAudioStreamReady,
+        didEmitReadyEvent: false,
+    };
+    const iv = setInterval(() => {
+        const t = nowMs();
+        for (let s = 0; s < slotCount; s++) {
+            const st = slots[s];
+            const w = writers[s];
+            const frameMs = (st.lastFrames / STREAM_INPUT_SAMPLE_RATE_IN_HZ) * 1000;
+            if (t >= st.nextDueMs) {
+                const buf = st.q.length ? st.q.shift() : Buffer.alloc(st.lastFrames * BYTES_PER_SAMPLE);
+                if (!w.write(buf)) {
+                    const late = t - st.nextDueMs;
+                    const steps = Math.max(1, Math.ceil(late / frameMs));
+                    st.nextDueMs += steps * frameMs;
+                    continue;
+                }
+                const late = t - st.nextDueMs;
+                const steps = Math.max(1, Math.ceil(late / frameMs));
+                st.nextDueMs += steps * frameMs;
+            }
+        }
+        if (!outputPacerState)
+            return;
+        const state = outputPacerState;
+        if (t >= state.nextDueMs) {
+            const samples = state.frameQueue.length > 0 ? state.frameQueue.shift() : new Int16Array(FRAME_10MS_SAMPLES);
+            if (!state.didEmitReadyEvent) {
+                state.onAudioStreamReady();
+                state.didEmitReadyEvent = true;
+            }
+            state.rtcAudioSource.onData({
+                samples: samples,
+                sampleRate: STREAM_INPUT_SAMPLE_RATE_IN_HZ,
+            });
+            const late = t - state.nextDueMs;
+            const steps = Math.max(1, Math.ceil(late / outputFrameMs));
+            state.nextDueMs += steps * outputFrameMs;
+        }
+    }, 5);
+    stopPacerFn = () => clearInterval(iv);
+}
+function stopPacer() {
+    if (stopPacerFn)
+        stopPacerFn();
+    stopPacerFn = null;
+    slots = [];
+}
+function enqueueFrame(slot, samples, numberOfFrames) {
+    const st = slots[slot];
+    if (!st)
+        return;
+    const buf = Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength);
+    st.q.push(buf);
+}
+function clearSlotQueue(slot) {
+    const st = slots[slot];
+    if (st) {
+        st.q = [];
+        const now = Number(process.hrtime.bigint()) / 1e6;
+        const frameMs = (st.lastFrames / STREAM_INPUT_SAMPLE_RATE_IN_HZ) * 1000;
+        st.nextDueMs = now + frameMs;
+    }
+}
+function getFFmpegArguments() {
+    const N = PARTICIPANT_SLOTS;
+    const SR = STREAM_INPUT_SAMPLE_RATE_IN_HZ;
+    const ffArgs = [];
+    for (let i = 0; i < N; i++) {
+        ffArgs.push("-f", "s16le", "-ar", String(SR), "-ac", "1", "-i", `pipe:${3 + i}`);
+    }
+    const pre = [];
+    for (let i = 0; i < N; i++) {
+        pre.push(`[${i}:a]aresample=async=1:first_pts=0,asetpts=N/SR/TB[a${i}]`);
+    }
+    const labels = Array.from({ length: N }, (_, i) => `[a${i}]`).join("");
+    const amix = `${labels}amix=inputs=${N}:duration=longest:dropout_transition=250:normalize=0[mix]`;
+    const filter = `${pre.join(";")};${amix}`;
+    ffArgs.push("-hide_banner", "-nostats", "-loglevel", "error", "-filter_complex", filter, "-map", "[mix]", "-f", "s16le", "-ar", String(SR), "-ac", "1", "-c:a", "pcm_s16le", "pipe:1");
+    return ffArgs;
+}
+function spawnFFmpegProcess(rtcAudioSource, onAudioStreamReady) {
+    const stdio = ["ignore", "pipe", "pipe", ...Array(PARTICIPANT_SLOTS).fill("pipe")];
+    const args = getFFmpegArguments();
+    const ffmpegProcess = child_process.spawn("ffmpeg", args, { stdio });
+    startPacer(ffmpegProcess, PARTICIPANT_SLOTS, rtcAudioSource, onAudioStreamReady);
+    ffmpegProcess.stderr.setEncoding("utf8");
+    ffmpegProcess.stderr.on("data", (d) => console.error("[ffmpeg]", String(d).trim()));
+    ffmpegProcess.on("error", () => console.error("FFmpeg process error: is ffmpeg installed?"));
+    let audioBuffer = Buffer.alloc(0);
+    const FRAME_SIZE_BYTES = FRAME_10MS_SAMPLES * BYTES_PER_SAMPLE;
+    ffmpegProcess.stdout.on("data", (chunk) => {
+        audioBuffer = Buffer.concat([audioBuffer, chunk]);
+        while (audioBuffer.length >= FRAME_SIZE_BYTES) {
+            const frameData = audioBuffer.subarray(0, FRAME_SIZE_BYTES);
+            const samples = new Int16Array(FRAME_10MS_SAMPLES);
+            for (let i = 0; i < FRAME_10MS_SAMPLES; i++) {
+                samples[i] = frameData.readInt16LE(i * 2);
+            }
+            enqueueOutputFrame(samples);
+            audioBuffer = audioBuffer.subarray(FRAME_SIZE_BYTES);
+        }
+    });
+    return ffmpegProcess;
+}
+function writeAudioDataToFFmpeg(ffmpegProcess, slot, audioTrack) {
+    const writer = ffmpegProcess.stdio[3 + slot];
+    const sink = new AudioSink(audioTrack);
+    const unsubscribe = sink.subscribe(({ samples, sampleRate: sr, channelCount: ch, bitsPerSample, numberOfFrames }) => {
+        if (ch !== 1 || bitsPerSample !== 16)
+            return;
+        let out = samples;
+        if (sr !== STREAM_INPUT_SAMPLE_RATE_IN_HZ) {
+            const resampled = resampleTo48kHz(samples, sr, numberOfFrames !== null && numberOfFrames !== void 0 ? numberOfFrames : samples.length);
+            out = resampled;
+        }
+        appendAndDrainTo480(slot, out);
+    });
+    const stop = () => {
+        try {
+            unsubscribe();
+            sink.stop();
+        }
+        catch (_a) {
+            console.error("Failed to stop AudioSink");
+        }
+    };
+    return { sink, writer, stop };
+}
+function stopFFmpegProcess(ffmpegProcess) {
+    stopPacer();
+    if (ffmpegProcess && !ffmpegProcess.killed) {
+        try {
+            ffmpegProcess.stdout.unpipe();
+        }
+        catch (_a) {
+            console.error("Failed to unpipe ffmpeg stdout");
+        }
+        for (let i = 0; i < PARTICIPANT_SLOTS; i++) {
+            const w = ffmpegProcess.stdio[3 + i];
+            try {
+                w.end();
+            }
+            catch (_b) {
+                console.error("Failed to end ffmpeg writable stream");
+            }
+        }
+        ffmpegProcess.kill("SIGTERM");
+    }
+}
+
+class AudioMixer extends events.EventEmitter {
+    constructor(onStreamReady) {
+        super();
+        this.ffmpegProcess = null;
+        this.combinedAudioStream = null;
+        this.rtcAudioSource = null;
+        this.participantSlots = new Map();
+        this.activeSlots = {};
+        this.setupMediaStream();
+        this.participantSlots = new Map(Array.from({ length: PARTICIPANT_SLOTS }, (_, i) => [i, ""]));
+        this.onStreamReady = onStreamReady;
+    }
+    setupMediaStream() {
+        this.rtcAudioSource = new wrtc.nonstandard.RTCAudioSource();
+        const audioTrack = this.rtcAudioSource.createTrack();
+        this.combinedAudioStream = new wrtc.MediaStream([audioTrack]);
+    }
+    getCombinedAudioStream() {
+        return this.combinedAudioStream;
+    }
+    handleRemoteParticipants(participants) {
+        if (participants.length === 0) {
+            this.stopAudioMixer();
+            return;
+        }
+        if (!this.ffmpegProcess && this.rtcAudioSource) {
+            this.ffmpegProcess = spawnFFmpegProcess(this.rtcAudioSource, this.onStreamReady);
+        }
+        for (const p of participants)
+            this.attachParticipantIfNeeded(p);
+        const liveIds = new Set(participants.map((p) => p.id).filter(Boolean));
+        for (const [slot, pid] of this.participantSlots) {
+            if (pid && !liveIds.has(pid))
+                this.detachParticipant(pid);
+        }
+    }
+    stopAudioMixer() {
+        if (this.ffmpegProcess) {
+            stopFFmpegProcess(this.ffmpegProcess);
+            this.ffmpegProcess = null;
+        }
+        this.participantSlots = new Map(Array.from({ length: PARTICIPANT_SLOTS }, (_, i) => [i, ""]));
+        this.activeSlots = {};
+        this.setupMediaStream();
+    }
+    slotForParticipant(participantId) {
+        var _a;
+        const found = (_a = [...this.participantSlots.entries()].find(([, id]) => id === participantId)) === null || _a === void 0 ? void 0 : _a[0];
+        return found === undefined ? null : found;
+    }
+    acquireSlot(participantId) {
+        var _a;
+        const existing = this.slotForParticipant(participantId);
+        if (existing !== null)
+            return existing;
+        const empty = (_a = [...this.participantSlots.entries()].find(([, id]) => id === "")) === null || _a === void 0 ? void 0 : _a[0];
+        if (empty === undefined)
+            return null;
+        this.participantSlots.set(empty, participantId);
+        return empty;
+    }
+    attachParticipantIfNeeded(participant) {
+        var _a;
+        const { id: participantId, stream: participantStream, isAudioEnabled } = participant;
+        if (!participantId)
+            return;
+        if (!participantStream || !isAudioEnabled) {
+            this.detachParticipant(participantId);
+            return;
+        }
+        const audioTrack = participantStream.getTracks().find((t) => t.kind === "audio");
+        if (!audioTrack) {
+            this.detachParticipant(participantId);
+            return;
+        }
+        const slot = this.acquireSlot(participantId);
+        if (slot === null)
+            return;
+        const existing = this.activeSlots[slot];
+        if (existing && existing.trackId === audioTrack.id)
+            return;
+        if (existing) {
+            try {
+                existing.stop();
+            }
+            catch (e) {
+                console.error("Failed to stop existing audio track", { error: e });
+            }
+            this.activeSlots[slot] = undefined;
+        }
+        const { sink, writer, stop } = writeAudioDataToFFmpeg(this.ffmpegProcess, slot, audioTrack);
+        this.activeSlots[slot] = { sink, writer, stop, trackId: audioTrack.id };
+        (_a = audioTrack.addEventListener) === null || _a === void 0 ? void 0 : _a.call(audioTrack, "ended", () => this.detachParticipant(participantId));
+    }
+    detachParticipant(participantId) {
+        const slot = this.slotForParticipant(participantId);
+        if (slot === null)
+            return;
+        const binding = this.activeSlots[slot];
+        if (binding) {
+            try {
+                binding.stop();
+            }
+            catch (e) {
+                console.error("Failed to stop existing audio track", { error: e });
+            }
+            this.activeSlots[slot] = undefined;
+        }
+        clearSlotQueue(slot);
+        this.participantSlots.set(slot, "");
+    }
+}
+
+exports.AudioMixer = AudioMixer;

package/dist/tools.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'events';
+import { RemoteParticipantState } from '@whereby.com/core';
+
+declare class AudioMixer extends EventEmitter {
+    private ffmpegProcess;
+    private combinedAudioStream;
+    private rtcAudioSource;
+    private participantSlots;
+    private activeSlots;
+    private onStreamReady;
+    constructor(onStreamReady: () => void);
+    private setupMediaStream;
+    getCombinedAudioStream(): MediaStream | null;
+    handleRemoteParticipants(participants: RemoteParticipantState[]): void;
+    stopAudioMixer(): void;
+    private slotForParticipant;
+    private acquireSlot;
+    private attachParticipantIfNeeded;
+    private detachParticipant;
+}
+
+export { AudioMixer };

package/package.json

@@ -2,11 +2,12 @@
   "name": "@whereby.com/assistant-sdk",
   "description": "Assistant SDK for whereby.com",
   "author": "Whereby AS",
-  "version": "0.0.0-canary-20250903113745",
+  "version": "0.0.0-canary-20250908163456",
   "license": "MIT",
   "files": [
     "dist",
-    "polyfills/package.json"
+    "polyfills/package.json",
+    "tools/package.json"
   ],
   "publishConfig": {
     "access": "public"
@@ -33,23 +34,33 @@
         "types": "./dist/polyfills.d.ts",
         "default": "./dist/polyfills.cjs"
       }
+    },
+    "./tools": {
+      "import": {
+        "types": "./dist/tools.d.ts",
+        "default": "./dist/tools.cjs"
+      },
+      "require": {
+        "types": "./dist/tools.d.ts",
+        "default": "./dist/tools.cjs"
+      }
     }
   },
   "devDependencies": {
     "eslint": "^9.29.0",
     "prettier": "^3.5.3",
     "typescript": "^5.8.3",
-    "@whereby.com/rollup-config": "0.1.0",
-    "@whereby.com/prettier-config": "0.1.0",
-    "@whereby.com/jest-config": "0.1.0",
     "@whereby.com/eslint-config": "0.1.0",
+    "@whereby.com/jest-config": "0.1.0",
+    "@whereby.com/prettier-config": "0.1.0",
+    "@whereby.com/rollup-config": "0.1.0",
     "@whereby.com/tsconfig": "0.1.0"
   },
   "dependencies": {
     "@roamhq/wrtc": "github:whereby/node-webrtc#patch/rtc_audio_source",
     "uuid": "^11.0.3",
     "ws": "^8.18.0",
-    "@whereby.com/core": "0.0.0-canary-20250903113745"
+    "@whereby.com/core": "0.0.0-canary-20250908163456"
   },
   "prettier": "@whereby.com/prettier-config",
   "scripts": {

package/tools/package.json

@@ -0,0 +1,4 @@
+{
+    "main": "../dist/tools.cjs",
+    "types": "../dist/tools.d.ts"
+}