feat: add / remove events from agents sdk abstractions

Author: 1egoman

packages/react/src/hooks/useAgent.ts

@@ -47,15 +47,13 @@ export type AgentState = 'disconnected' | 'connecting' | 'failed' | AgentSdkStat
 export enum AgentEvent {
   CameraChanged = 'cameraChanged',
   MicrophoneChanged = 'microphoneChanged',
-  AttributesChanged = 'attributesChanged',
   StateChanged = 'stateChanged',
 }
 
 /** @public */
 export type AgentCallbacks = {
   [AgentEvent.CameraChanged]: (newTrack: TrackReference | null) => void;
   [AgentEvent.MicrophoneChanged]: (newTrack: TrackReference | null) => void;
-  [AgentEvent.AttributesChanged]: (newAttributes: Record<string, string>) => void;
   [AgentEvent.StateChanged]: (newAgentState: AgentState) => void;
 };
 
@@ -317,7 +315,6 @@ export function useAgent(session?: SessionStub): UseAgentReturn {
 
     const handleAttributesChanged = (attributes: UseAgentReturn['attributes']) => {
       setAgentParticipantAttributes(attributes);
-      emitter.emit(AgentEvent.AttributesChanged, attributes);
     };
 
     agentParticipant.on(ParticipantEvent.AttributesChanged, handleAttributesChanged);

packages/react/src/hooks/useSession.ts

@@ -21,13 +21,24 @@ import { useLocalParticipant } from './useLocalParticipant';
 /** @public */
 export enum SessionEvent {
   ConnectionStateChanged = 'connectionStateChanged',
-  MediaDevicesError = 'MediaDevicesError',
+  /**
+   * Emits when an error is encountered while attempting to create a track.
+   * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
+   * args: (error: Error, kind: MediaDeviceKind)
+   */
+  MediaDevicesError = 'mediaDevicesError',
+  /**
+   * Emits when an error is received while decrypting frame received frame information.
+   * args: (error: Error)
+   */
+  EncryptionError = 'encryptionError',
 }
 
 /** @public */
 export type SessionCallbacks = {
   [SessionEvent.ConnectionStateChanged]: (newAgentConnectionState: ConnectionState) => void;
   [SessionEvent.MediaDevicesError]: (error: Error) => void;
+  [SessionEvent.EncryptionError]: (error: Error) => void;
 };
 
 /** @public */
@@ -215,6 +226,17 @@ export function useSession(
     };
   }, [room, emitter]);
 
+  useEffect(() => {
+    const handleEncryptionError = async (error: Error) => {
+      emitter.emit(SessionEvent.EncryptionError, error);
+    };
+
+    room.on(RoomEvent.EncryptionError, handleEncryptionError);
+    return () => {
+      room.off(RoomEvent.EncryptionError, handleEncryptionError);
+    };
+  }, [room, emitter]);
+
   const { localParticipant } = useLocalParticipant({ room });
   const cameraPublication = localParticipant.getTrackPublication(Track.Source.Camera);
   const localCamera = useMemo(() => {

packages/react/src/hooks/useSessionMessages.ts

@@ -1,7 +1,7 @@
-import { useMemo } from 'react';
-// import type TypedEventEmitter from 'typed-emitter';
+import { useEffect, useMemo, useRef } from 'react';
+import type TypedEventEmitter from 'typed-emitter';
 import { SendTextOptions } from 'livekit-client';
-// import { EventEmitter } from "events";
+import { EventEmitter } from "events";
 import {
   ReceivedMessage,
   ReceivedChatMessage,
@@ -25,10 +25,9 @@ export type UseSessionMessagesReturn = {
 
   send: (message: string, options?: SendTextOptions) => Promise<ReceivedChatMessage>;
 
-  // FIXME: does there need to be a way to subscribe to individual messages?
-  // internal: {
-  //   emitter: TypedEventEmitter<MessagesCallbacks>;
-  // };
+  internal: {
+    emitter: TypedEventEmitter<MessagesCallbacks>;
+  };
 };
 
 /** @public */
@@ -46,6 +45,8 @@ export type MessagesCallbacks = {
 export function useSessionMessages(session?: UseSessionReturn): UseSessionMessagesReturn {
   const { room } = useEnsureSession(session);
 
+  const emitter = useMemo(() => new EventEmitter() as TypedEventEmitter<MessagesCallbacks>, []);
+
   const agent = useAgent(session);
 
   const transcriptions: Array<TextStreamData> = useTranscriptions({ room });
@@ -105,11 +106,24 @@ export function useSessionMessages(session?: UseSessionReturn): UseSessionMessag
     return merged.sort((a, b) => a.timestamp - b.timestamp);
   }, [transcriptionMessages, chat.chatMessages]);
 
+  const previouslyReceivedMessageIdsRef = useRef(new Set());
+  useEffect(() => {
+    for (const message of receivedMessages) {
+      if (previouslyReceivedMessageIdsRef.current.has(message.id)) {
+        continue;
+      }
+
+      previouslyReceivedMessageIdsRef.current.add(message.id);
+      emitter.emit(MessagesEvent.MessageReceived, message);
+    }
+  }, [receivedMessages]);
+
   return useMemo(
     () => ({
       messages: receivedMessages,
       send: chat.send,
       isSending: chat.isSending,
+      internal: { emitter },
     }),
     [receivedMessages, chat.send, chat.isSending],
   );