diff --git a/demo/app.tsx b/demo/app.tsx
index 5df62f90..6aa04403 100644
--- a/demo/app.tsx
+++ b/demo/app.tsx
@@ -2,7 +2,7 @@ import { ChatMode, ConnectionState } from '@sdk/types';
 import { useEffect, useRef, useState } from 'preact/hooks';
 
 import './app.css';
-import { agentId, clientKey, didApiUrl, didSocketApiUrl } from './environment';
+import { agentId, clientKey, debug, didApiUrl, didSocketApiUrl } from './environment';
 import { useAgentManager } from './hooks/useAgentManager';
 
 export function App() {
@@ -19,6 +19,7 @@ export function App() {
 
     const { srcObject, connectionState, messages, isSpeaking, connect, disconnect, speak, chat, interrupt } =
         useAgentManager({
+            debug,
             agentId,
             baseURL: didApiUrl,
             wsURL: didSocketApiUrl,
@@ -64,10 +65,10 @@ export function App() {
                             {connectionState === ConnectionState.Connected
                                 ? 'Send'
                                 : connectionState === ConnectionState.Connecting
-                                  ? 'Connecting...'
-                                  : connectionState === ConnectionState.Fail
-                                    ? 'Failed, Try Again'
-                                    : 'Connect'}
+                                    ? 'Connecting...'
+                                    : connectionState === ConnectionState.Fail
+                                        ? 'Failed, Try Again'
+                                        : 'Connect'}
                         </button>
 
                         <button
diff --git a/demo/environment.ts b/demo/environment.ts
index 413966e9..866808a5 100644
--- a/demo/environment.ts
+++ b/demo/environment.ts
@@ -1,4 +1,5 @@
 export const nodeEnv = import.meta.env.VITE_NODE_ENV as string;
+export const debug = (import.meta.env.VITE_DEBUG as boolean) || false;
 export const didApiUrl = import.meta.env.VITE_DID_API_URL as string;
 export const didSocketApiUrl = import.meta.env.VITE_WS_ENDPOINT as string;
 export const mixpanelKey = import.meta.env.VITE_MIXPANEL_KEY as string;
diff --git a/demo/hooks/useAgentManager.ts b/demo/hooks/useAgentManager.ts
index 600359b2..3696d393 100644
--- a/demo/hooks/useAgentManager.ts
+++ b/demo/hooks/useAgentManager.ts
@@ -27,6 +27,7 @@ interface UseAgentManagerOptions {
     externalId?: string;
     mixpanelKey?: string;
     mixpanelAdditionalProperties?: Record<string, any>;
+    debug?: boolean;
 }
 
 export function useAgentManager(props: UseAgentManagerOptions) {
@@ -41,6 +42,7 @@ export function useAgentManager(props: UseAgentManagerOptions) {
         streamOptions,
         mixpanelKey,
         mixpanelAdditionalProperties,
+        debug,
     } = props;
 
     const [isSpeaking, setIsSpeaking] = useState(false);
@@ -104,6 +106,7 @@ export function useAgentManager(props: UseAgentManagerOptions) {
                 mixpanelKey,
                 mixpanelAdditionalProperties,
                 streamOptions,
+                debug,
             });
 
             await newManager.connect();
diff --git a/src/services/agent-manager/connect-to-manager.ts b/src/services/agent-manager/connect-to-manager.ts
index 8151904f..107980f0 100644
--- a/src/services/agent-manager/connect-to-manager.ts
+++ b/src/services/agent-manager/connect-to-manager.ts
@@ -12,6 +12,7 @@ import {
     AgentsAPI,
     Chat,
     ChatMode,
+    ChatProgressCallback,
     ConnectionState,
     CreateStreamOptions,
     CreateStreamV2Options,
@@ -158,6 +159,8 @@ function trackLegacyVideoAnalytics(
 type ConnectToManagerOptions = AgentManagerOptions & {
     callbacks: AgentManagerOptions['callbacks'] & {
         onVideoIdChange?: (videoId: string | null) => void;
+        /** Internal callback for livekit-manager data channel events */
+        onMessage?: ChatProgressCallback;
     };
     chatId?: string;
 };
@@ -172,6 +175,8 @@ function connectToManager(
     return new Promise(async (resolve, reject) => {
         try {
             let streamingManager: StreamingManager<CreateStreamOptions | CreateStreamV2Options>;
+            let shouldResolveOnComplete = false;
+
             streamingManager = await createStreamingManager(agent, getAgentStreamOptions(agent, options), {
                 ...options,
                 analytics,
@@ -181,7 +186,13 @@ function connectToManager(
                         options.callbacks.onConnectionStateChange?.(state);
 
                         if (state === ConnectionState.Connected) {
-                            resolve(streamingManager);
+                            // If manager is ready, resolve immediately
+                            // Otherwise, mark to resolve after manager is created
+                            if (streamingManager) {
+                                resolve(streamingManager);
+                            } else {
+                                shouldResolveOnComplete = true;
+                            }
                         }
                     },
                     onVideoStateChange: (state: StreamingState, statsReport?: any) => {
@@ -213,6 +224,10 @@ function connectToManager(
                     },
                 },
             });
+
+            if (shouldResolveOnComplete) {
+                resolve(streamingManager);
+            }
         } catch (error) {
             reject(error);
         }
diff --git a/src/services/agent-manager/index.ts b/src/services/agent-manager/index.ts
index 6c0d81f5..cf3068b1 100644
--- a/src/services/agent-manager/index.ts
+++ b/src/services/agent-manager/index.ts
@@ -3,6 +3,7 @@ import {
     AgentManagerOptions,
     Chat,
     ChatMode,
+    ChatResponse,
     ConnectionState,
     CreateStreamOptions,
     Interrupt,
@@ -15,6 +16,7 @@ import { CONNECTION_RETRY_TIMEOUT_MS } from '@sdk/config/consts';
 import { didApiUrl, didSocketApiUrl, mixpanelKey } from '@sdk/config/environment';
 import { ChatCreationFailed, ValidationError } from '@sdk/errors';
 import { getRandom } from '@sdk/utils';
+import { isStreamsV2Agent } from '@sdk/utils/agent';
 import { isChatModeWithoutChat, isTextualChat } from '@sdk/utils/chat';
 import { createAgentsApi } from '../../api/agents';
 import { getAgentInfo, getAnalyticsInfo } from '../../utils/analytics';
@@ -72,6 +74,7 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
     const agentsApi = createAgentsApi(options.auth, baseURL, options.callbacks.onError, options.externalId);
 
     const agentEntity = await agentsApi.getById(agent);
+    const isStreamsV2 = isStreamsV2Agent(agentEntity.presenter.type);
     analytics.enrich(getAgentInfo(agentEntity));
 
     const { onMessage, clearQueue } = createMessageEventQueue(analytics, items, options, agentEntity, () =>
@@ -100,7 +103,7 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
         }
 
         const websocketPromise =
-            options.mode === ChatMode.DirectPlayback
+            options.mode === ChatMode.DirectPlayback || isStreamsV2
                 ? Promise.resolve(undefined)
                 : createSocketManager(
                       options.auth,
@@ -113,7 +116,10 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
             () => {
                 return initializeStreamAndChat(
                     agentEntity,
-                    { ...options, callbacks: { ...options.callbacks, onVideoIdChange: updateVideoId } },
+                    {
+                        ...options,
+                        callbacks: { ...options.callbacks, onVideoIdChange: updateVideoId, onMessage },
+                    },
                     agentsApi,
                     analytics,
                     items.chat
@@ -253,41 +259,45 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
             };
 
             const sendChatRequest = async (messages: Message[], chatId: string) => {
-                return retryOperation(
-                    () => {
-                        return agentsApi.chat(
-                            agentEntity.id,
-                            chatId,
-                            {
-                                chatMode: items.chatMode,
-                                streamId: items.streamingManager?.streamId,
-                                sessionId: items.streamingManager?.sessionId,
-                                messages: messages.map(({ matches, ...message }) => message),
-                            },
-                            {
-                                ...getRequestHeaders(items.chatMode),
-                                skipErrorHandler: true,
-                            }
-                        );
+                const chatRequestFn = isStreamsV2
+                    ? async () => {
+                          await items.streamingManager?.sendTextMessage?.(userMessage);
+                          return Promise.resolve({} as ChatResponse);
+                      }
+                    : async () => {
+                          return agentsApi.chat(
+                              agentEntity.id,
+                              chatId,
+                              {
+                                  chatMode: items.chatMode,
+                                  streamId: items.streamingManager?.streamId,
+                                  sessionId: items.streamingManager?.sessionId,
+                                  messages: messages.map(({ matches, ...message }) => message),
+                              },
+                              {
+                                  ...getRequestHeaders(items.chatMode),
+                                  skipErrorHandler: true,
+                              }
+                          );
+                      };
+
+                return retryOperation(chatRequestFn, {
+                    limit: 2,
+                    shouldRetryFn: error => {
+                        const isInvalidSessionId = error?.message?.includes('missing or invalid session_id');
+                        const isStreamError = error?.message?.includes('Stream Error');
+
+                        if (!isStreamError && !isInvalidSessionId) {
+                            options.callbacks.onError?.(error);
+                            return false;
+                        }
+                        return true;
                     },
-                    {
-                        limit: 2,
-                        shouldRetryFn: error => {
-                            const isInvalidSessionId = error?.message?.includes('missing or invalid session_id');
-                            const isStreamError = error?.message?.includes('Stream Error');
-
-                            if (!isStreamError && !isInvalidSessionId) {
-                                options.callbacks.onError?.(error);
-                                return false;
-                            }
-                            return true;
-                        },
-                        onRetry: async () => {
-                            await disconnect();
-                            await connect(false);
-                        },
-                    }
-                );
+                    onRetry: async () => {
+                        await disconnect();
+                        await connect(false);
+                    },
+                });
             };
 
             try {
diff --git a/src/services/streaming-manager/advanced.test.ts b/src/services/streaming-manager/advanced.test.ts
index 916fd804..dd783c28 100644
--- a/src/services/streaming-manager/advanced.test.ts
+++ b/src/services/streaming-manager/advanced.test.ts
@@ -396,8 +396,7 @@ describe('Streaming Manager Advanced', () => {
                 expect.anything(),
                 expect.anything(),
                 expect.anything(),
-                expect.any(Function),
-                false
+                expect.any(Function)
             );
 
             const connectivityCallback = (pollStats as jest.Mock).mock.calls[0][4];
@@ -422,8 +421,7 @@ describe('Streaming Manager Advanced', () => {
                 expect.anything(),
                 expect.anything(),
                 expect.anything(),
-                expect.anything(),
-                false
+                expect.anything()
             );
 
             expect(manager.streamId).toBe('streamId');
diff --git a/src/services/streaming-manager/business-flows.test.ts b/src/services/streaming-manager/business-flows.test.ts
index 1358e772..2d283da8 100644
--- a/src/services/streaming-manager/business-flows.test.ts
+++ b/src/services/streaming-manager/business-flows.test.ts
@@ -5,7 +5,6 @@
 
 import { StreamApiFactory, StreamingAgentFactory, StreamingManagerOptionsFactory } from '../../test-utils/factories';
 import { AgentActivityState, CreateStreamOptions, StreamType, StreamingManagerOptions } from '../../types/index';
-import { pollStats } from './stats/poll';
 import { createWebRTCStreamingManager as createStreamingManager } from './webrtc-manager';
 
 // Mock createStreamApi
@@ -146,51 +145,6 @@ describe('Streaming Manager Business Flows', () => {
         });
     });
 
-    describe('Warmup Mode Flows', () => {
-        it('should handle warmup=true with legacy stream', async () => {
-            const warmupAgent = { ...agent, stream_warmup: true };
-            const manager = await createStreamingManager(agentId, warmupAgent, options);
-
-            // Warmup should be enabled for legacy streams
-            expect(pollStats).toHaveBeenCalledWith(
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                true // warmup = true
-            );
-
-            expect(manager.streamId).toBe('streamId');
-        });
-
-        it('should handle warmup=true with fluent stream (should disable warmup)', async () => {
-            mockApi.createStream.mockResolvedValueOnce({
-                id: 'streamId',
-                offer: { type: 'offer', sdp: 'sdp' },
-                ice_servers: [],
-                session_id: 'sessionId',
-                fluent: true,
-                interrupt_enabled: false,
-            });
-
-            const warmupAgent = { ...agent, stream_warmup: true };
-            const manager = await createStreamingManager(agentId, warmupAgent, options);
-
-            // Warmup should be disabled for fluent streams
-            expect(pollStats).toHaveBeenCalledWith(
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                false // warmup = false for fluent
-            );
-
-            expect(manager.streamType).toBe(StreamType.Fluent);
-        });
-    });
-
     describe('Error Handling Flows', () => {
         it('should handle connection failure', async () => {
             mockApi.createStream.mockRejectedValueOnce(new Error('Connection failed'));
diff --git a/src/services/streaming-manager/common.ts b/src/services/streaming-manager/common.ts
index e34d4f2a..60752df7 100644
--- a/src/services/streaming-manager/common.ts
+++ b/src/services/streaming-manager/common.ts
@@ -25,6 +25,13 @@ export type StreamingManager<T extends CreateStreamOptions | CreateStreamV2Optio
      */
     sendDataChannelMessage(payload: string): void;
 
+    /**
+     * Method to send text messages to the server
+     * @param payload The message payload to send
+     * supported only for livekit manager
+     */
+    sendTextMessage?(payload: string): Promise<void>;
+
     /**
      * Session identifier information, should be returned in the body of all streaming requests
      */
diff --git a/src/services/streaming-manager/livekit-manager.ts b/src/services/streaming-manager/livekit-manager.ts
index addf97a0..cb0f166a 100644
--- a/src/services/streaming-manager/livekit-manager.ts
+++ b/src/services/streaming-manager/livekit-manager.ts
@@ -11,16 +11,20 @@ import {
     StreamType,
     TransportProvider,
 } from '@sdk/types';
+import { ChatProgress } from '@sdk/types/entities/agents/manager';
 import { createStreamApiV2 } from '../../api/streams/streamsApiV2';
 import { didApiUrl } from '../../config/environment';
 import { createStreamingLogger, StreamingManager } from './common';
 
 import type {
+    ConnectionQuality,
     ConnectionState as LiveKitConnectionState,
+    Participant,
     RemoteParticipant,
     RemoteTrack,
     Room,
     RoomEvent,
+    SubscriptionError,
 } from 'livekit-client';
 
 async function importLiveKit(): Promise<{
@@ -39,6 +43,32 @@ async function importLiveKit(): Promise<{
     }
 }
 
+const connectivityQualityToState = {
+    excellent: ConnectivityState.Strong,
+    good: ConnectivityState.Strong,
+    poor: ConnectivityState.Weak,
+    lost: ConnectivityState.Unknown,
+    unknown: ConnectivityState.Unknown,
+};
+
+const internalErrorMassage = JSON.stringify({
+    kind: 'InternalServerError',
+    description: 'Stream Error',
+});
+
+export function handleInitError(
+    error: unknown,
+    log: (message?: any, ...optionalParams: any[]) => void,
+    callbacks: StreamingManagerOptions['callbacks'],
+    markInitialConnectionDone: () => void
+): void {
+    log('Failed to connect to LiveKit room:', error);
+    markInitialConnectionDone();
+    callbacks.onConnectionStateChange?.(ConnectionState.Fail);
+    callbacks.onError?.(error as Error, { streamId: '' });
+    throw error;
+}
+
 export async function createLiveKitStreamingManager<T extends CreateStreamV2Options>(
     agentId: string,
     agent: T,
@@ -58,15 +88,75 @@ export async function createLiveKitStreamingManager<T extends CreateStreamV2Opti
     let room: Room | null = null;
     let isConnected = false;
     let videoId: string | null = null;
-    let mediaStream: MediaStream | null = null;
     const streamType = StreamType.Fluent;
+    let isInitialConnection = true;
+    let sharedMediaStream: MediaStream | null = null;
 
     room = new Room({
-        adaptiveStream: true,
+        adaptiveStream: false, // Must be false to use mediaStreamTrack directly
         dynacast: true,
     });
 
-    room.on(RoomEvent.ConnectionStateChanged, state => {
+    const streamApi = createStreamApiV2(auth, baseURL || didApiUrl, agentId, callbacks.onError);
+    let streamId: string | undefined;
+    let sessionId: string | undefined;
+
+    let token: string | undefined;
+    let url: string | undefined;
+
+    try {
+        const streamResponse = await streamApi.createStream({
+            transport_provider: TransportProvider.Livekit,
+            chat_id: agent.chat_id,
+        });
+
+        const { session_id, session_token, session_url } = streamResponse;
+        callbacks.onStreamCreated?.({ stream_id: session_id, session_id, agent_id: agentId });
+        streamId = session_id;
+        sessionId = session_id;
+        token = session_token;
+        url = session_url;
+
+        await room.prepareConnection(url, token);
+    } catch (error) {
+        handleInitError(error, log, callbacks, () => {
+            isInitialConnection = false;
+        });
+    }
+
+    if (!url || !token || !streamId || !sessionId) {
+        return Promise.reject(new Error('Failed to initialize LiveKit stream'));
+    }
+
+    room.on(RoomEvent.ConnectionStateChanged, handleConnectionStateChanged)
+        .on(RoomEvent.ConnectionQualityChanged, handleConnectionQualityChanged)
+        .on(RoomEvent.ActiveSpeakersChanged, handleActiveSpeakersChanged)
+        .on(RoomEvent.ParticipantConnected, handleParticipantConnected)
+        .on(RoomEvent.TrackSubscribed, handleTrackSubscribed)
+        .on(RoomEvent.TrackUnsubscribed, handleTrackUnsubscribed)
+        .on(RoomEvent.DataReceived, handleDataReceived)
+        .on(RoomEvent.MediaDevicesError, handleMediaDevicesError)
+        .on(RoomEvent.EncryptionError, handleEncryptionError)
+        .on(RoomEvent.TrackSubscriptionFailed, handleTrackSubscriptionFailed);
+
+    callbacks.onConnectionStateChange?.(ConnectionState.New);
+
+    try {
+        await room.connect(url, token);
+        log('LiveKit room joined successfully');
+
+        isInitialConnection = false;
+    } catch (error) {
+        handleInitError(error, log, callbacks, () => {
+            isInitialConnection = false;
+        });
+    }
+
+    analytics.enrich({
+        'stream-type': streamType,
+    });
+
+    function handleConnectionStateChanged(state: LiveKitConnectionState): void {
         log('Connection state changed:', state);
         switch (state) {
             case LiveKitConnectionState.Connecting:
@@ -75,7 +165,14 @@ export async function createLiveKitStreamingManager<T extends CreateStreamV2Opti
             case LiveKitConnectionState.Connected:
                 log('LiveKit room connected successfully');
                 isConnected = true;
-                callbacks.onConnectionStateChange?.(ConnectionState.Connected);
+                // During initial connection, defer the callback to ensure manager is returned first
+                if (isInitialConnection) {
+                    queueMicrotask(() => {
+                        callbacks.onConnectionStateChange?.(ConnectionState.Connected);
+                    });
+                } else {
+                    callbacks.onConnectionStateChange?.(ConnectionState.Connected);
+                }
                 break;
             case LiveKitConnectionState.Disconnected:
                 log('LiveKit room disconnected');
@@ -91,111 +188,121 @@ export async function createLiveKitStreamingManager<T extends CreateStreamV2Opti
                 callbacks.onConnectionStateChange?.(ConnectionState.Connecting);
                 break;
         }
-    });
+    }
 
-    room.on(RoomEvent.ConnectionQualityChanged, (quality, participant) => {
-        if (participant?.isLocal && quality === 'poor') {
-            log('Connection quality is poor');
-            callbacks.onConnectivityStateChange?.(ConnectivityState.Weak);
+    function handleConnectionQualityChanged(quality: ConnectionQuality, participant?: Participant): void {
+        log('Connection quality:', quality);
+        if (participant?.isLocal) {
+            callbacks.onConnectivityStateChange?.(connectivityQualityToState[quality]);
         }
-    });
+    }
 
-    // Handle room closure - this would be handled by the server or other means
-    // For now, we'll handle Closed state in disconnect method
+    function handleActiveSpeakersChanged(activeSpeakers: Participant[]): void {
+        log('Active speakers changed:', activeSpeakers);
+        const activeSpeaker = activeSpeakers[0];
+        if (activeSpeaker) {
+            callbacks.onAgentActivityStateChange?.(AgentActivityState.Talking);
+        } else {
+            callbacks.onAgentActivityStateChange?.(AgentActivityState.Idle);
+        }
+    }
 
-    room.on(RoomEvent.ParticipantConnected, (participant: RemoteParticipant) => {
+    function handleParticipantConnected(participant: RemoteParticipant): void {
         log('Participant connected:', participant.identity);
-    });
+    }
 
-    room.on(RoomEvent.TrackSubscribed, (track: RemoteTrack, publication, participant: RemoteParticipant) => {
+    function handleTrackSubscribed(track: RemoteTrack, publication: any, participant: RemoteParticipant): void {
         log(`Track subscribed: ${track.kind} from ${participant.identity}`);
 
-        if (!mediaStream) {
-            mediaStream = new MediaStream([track.mediaStreamTrack]);
-        } else {
-            mediaStream.addTrack(track.mediaStreamTrack);
+        const mediaStreamTrack = track.mediaStreamTrack;
+        if (!mediaStreamTrack) {
+            log(`No mediaStreamTrack available for ${track.kind}`);
+            return;
         }
 
-        callbacks.onSrcObjectReady?.(mediaStream);
+        // Create shared stream if it doesn't exist, or add track to existing stream
+        if (!sharedMediaStream) {
+            sharedMediaStream = new MediaStream([mediaStreamTrack]);
+            log(`Created shared MediaStream with ${track.kind} track`);
+        } else {
+            sharedMediaStream.addTrack(mediaStreamTrack);
+            log(`Added ${track.kind} track to shared MediaStream`);
+        }
 
-        // Handle video track subscription as stats signal for fluent streams
         if (track.kind === 'video') {
+            callbacks.onSrcObjectReady?.(sharedMediaStream);
             callbacks.onVideoStateChange?.(StreamingState.Start);
         }
-    });
+    }
 
-    room.on(RoomEvent.TrackUnsubscribed, (track: RemoteTrack, publication, participant: RemoteParticipant) => {
+    function handleTrackUnsubscribed(track: RemoteTrack, publication: any, participant: RemoteParticipant): void {
         log(`Track unsubscribed: ${track.kind} from ${participant.identity}`);
 
-        // Handle video track unsubscription as stats signal for fluent streams
         if (track.kind === 'video') {
             callbacks.onVideoStateChange?.(StreamingState.Stop);
         }
-    });
+    }
 
-    room.on(RoomEvent.DataReceived, (payload: Uint8Array, participant?: RemoteParticipant) => {
+    function handleDataReceived(payload: Uint8Array, participant?: RemoteParticipant): void {
         const message = new TextDecoder().decode(payload);
         log('Data received:', message);
 
         try {
             const data = JSON.parse(message);
-            if (data.subject === StreamEvents.StreamStarted && data.metadata?.videoId) {
-                videoId = data.metadata.videoId;
-                callbacks.onVideoIdChange?.(videoId);
-                callbacks.onAgentActivityStateChange?.(AgentActivityState.Talking);
-            } else if (data.subject === StreamEvents.StreamDone) {
-                videoId = null;
-                callbacks.onVideoIdChange?.(videoId);
-                callbacks.onAgentActivityStateChange?.(AgentActivityState.Idle);
+            if (data.subject === StreamEvents.ChatAnswer) {
+                const eventName = ChatProgress.Answer;
+                callbacks.onMessage?.(eventName, {
+                    event: eventName,
+                    ...data,
+                });
             }
         } catch (e) {
             log('Failed to parse data channel message:', e);
         }
-    });
-
-    callbacks.onConnectionStateChange?.(ConnectionState.New);
-
-    const streamApi = createStreamApiV2(auth, baseURL || didApiUrl, agentId, callbacks.onError);
-    let streamId: string;
-    let sessionId: string;
+    }
 
-    try {
-        const streamResponse = await streamApi.createStream({
-            transport_provider: TransportProvider.Livekit,
-            chat_id: agent.chat_id,
-        });
+    function handleMediaDevicesError(error: Error): void {
+        log('Media devices error:', error);
+        callbacks.onError?.(new Error(internalErrorMassage), { streamId });
+    }
 
-        const { agent_id, session_id, session_token: token, session_url: url } = streamResponse;
-        streamId = agent_id;
-        sessionId = session_id;
+    function handleEncryptionError(error: Error): void {
+        log('Encryption error:', error);
+        callbacks.onError?.(new Error(internalErrorMassage), { streamId });
+    }
 
-        await room.connect(url, token);
-        log('LiveKit room joined successfully');
-    } catch (error) {
-        log('Failed to connect to LiveKit room:', error);
-        callbacks.onConnectionStateChange?.(ConnectionState.Fail);
-        callbacks.onError?.(error as Error, { streamId: '' });
-        throw error;
+    function handleTrackSubscriptionFailed(
+        trackSid: string,
+        participant: RemoteParticipant,
+        reason?: SubscriptionError
+    ): void {
+        log('Track subscription failed:', { trackSid, participant, reason });
     }
 
-    analytics.enrich({
-        'stream-type': streamType,
-    });
+    function cleanMediaStream(): void {
+        if (sharedMediaStream) {
+            sharedMediaStream.getTracks().forEach(track => track.stop());
+            sharedMediaStream = null;
+        }
+    }
 
-    async function sendDataChannelMessage(message: string) {
+    async function sendTextMessage(message: string) {
         if (!isConnected || !room) {
             log('Room is not connected for sending messages');
-            callbacks.onError?.(new Error('Room is not connected for sending messages'), {
+            callbacks.onError?.(new Error(internalErrorMassage), {
                 streamId,
             });
             return;
         }
 
         try {
-            await room.localParticipant.publishData(new TextEncoder().encode(message), { reliable: true });
-        } catch (e: any) {
-            log('Error sending data channel message', e);
-            callbacks.onError?.(e, { streamId });
+            await room.localParticipant.sendText(message, {
+                topic: 'lk.chat',
+            });
+            log('Message sent successfully:', message);
+        } catch (error) {
+            log('Failed to send message:', error);
+            callbacks.onError?.(new Error(internalErrorMassage), { streamId });
         }
     }
 
@@ -206,7 +313,7 @@ export async function createLiveKitStreamingManager<T extends CreateStreamV2Opti
                 payload,
             });
 
-            return sendDataChannelMessage(message);
+            return sendTextMessage(message);
         },
 
         async disconnect() {
@@ -214,16 +321,14 @@ export async function createLiveKitStreamingManager<T extends CreateStreamV2Opti
                 await room.disconnect();
                 room = null;
             }
-            if (mediaStream) {
-                mediaStream.getTracks().forEach(track => track.stop());
-                mediaStream = null;
-            }
+            cleanMediaStream();
             isConnected = false;
             callbacks.onConnectionStateChange?.(ConnectionState.Completed);
             callbacks.onAgentActivityStateChange?.(AgentActivityState.Idle);
         },
 
-        sendDataChannelMessage,
+        sendDataChannelMessage: sendTextMessage,
+        sendTextMessage,
 
         sessionId,
         streamId,
diff --git a/src/services/streaming-manager/stats/poll.ts b/src/services/streaming-manager/stats/poll.ts
index d0f1d7b4..4ebcce95 100644
--- a/src/services/streaming-manager/stats/poll.ts
+++ b/src/services/streaming-manager/stats/poll.ts
@@ -43,11 +43,8 @@ export function pollStats(
     getIsConnected: () => boolean,
     onConnected: () => void,
     onVideoStateChange?: (state: StreamingState, statsReport?: VideoRTCStatsReport) => void,
-    onConnectivityStateChange?: (state: ConnectivityState) => void,
-    warmup: boolean = false
+    onConnectivityStateChange?: (state: ConnectivityState) => void
 ) {
-    const streamsBeforeReady = warmup ? 1 : 0;
-
     let allStats: SlimRTCStatsReport[] = [];
     let previousStats: SlimRTCStatsReport;
     let notReceivingNumIntervals = 0;
diff --git a/src/services/streaming-manager/stats/report.ts b/src/services/streaming-manager/stats/report.ts
index 2d5363df..2c615891 100644
--- a/src/services/streaming-manager/stats/report.ts
+++ b/src/services/streaming-manager/stats/report.ts
@@ -77,12 +77,26 @@ function extractAnomalies(stats: AnalyticsRTCStatsReport[]): AnalyticsRTCStatsRe
 export function formatStats(stats: RTCStatsReport): SlimRTCStatsReport {
     let codec = '';
     let currRtt: number = 0;
+
     for (const report of stats.values()) {
         if (report && report.type === 'codec' && report.mimeType.startsWith('video')) {
             codec = report.mimeType.split('/')[1];
         }
         if (report && report.type === 'candidate-pair') {
-            currRtt = report.currentRoundTripTime;
+            const rtt = report.currentRoundTripTime;
+            const candidatePair = report as any;
+            const isNominated = candidatePair.nominated === true;
+
+            // Prioritize RTT from the nominated candidate-pair (the active connection path).
+            // This ensures we capture the actual network latency being used, not just any candidate.
+            // Only update if we have a valid positive RTT value to avoid overwriting with invalid data.
+            if (rtt > 0) {
+                if (isNominated) {
+                    currRtt = rtt;
+                } else if (currRtt === 0) {
+                    currRtt = rtt;
+                }
+            }
         }
         if (report && report.type === 'inbound-rtp' && report.kind === 'video') {
             return {
@@ -180,11 +194,14 @@ export function createVideoStatsReport(
             freezeDuration: report.freezeDuration - stats[index - 1].freezeDuration,
         };
     });
+
     const anomalies = extractAnomalies(differentialReport);
     const lowFpsCount = anomalies.reduce((acc, report) => acc + (report.causes!.includes('low fps') ? 1 : 0), 0);
+
     const avgJittersSamples = differentialReport
         .filter(stat => !!stat.avgJitterDelayInInterval)
         .map(stat => stat.avgJitterDelayInInterval);
+
     const avgRttSamples = differentialReport.filter(stat => !!stat.rtt).map(stat => stat.rtt);
 
     return {
diff --git a/src/services/streaming-manager/webrtc-core.test.ts b/src/services/streaming-manager/webrtc-core.test.ts
index 40e46864..0704d5c5 100644
--- a/src/services/streaming-manager/webrtc-core.test.ts
+++ b/src/services/streaming-manager/webrtc-core.test.ts
@@ -58,19 +58,6 @@ describe('Streaming Manager Core', () => {
             expect(options.analytics.enrich).toHaveBeenCalledWith({ 'stream-type': StreamType.Fluent });
         });
 
-        it('should handle warmup mode', async () => {
-            agentStreamOptions = { stream_warmup: true } as any;
-            await createStreamingManager(agentId, agentStreamOptions, options);
-            expect(pollStats).toHaveBeenCalledWith(
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                expect.anything(),
-                true
-            );
-        });
-
         it('should throw error when session_id is missing', async () => {
             mockApi.createStream.mockResolvedValueOnce({
                 id: 'streamId',
@@ -255,8 +242,7 @@ describe('Streaming Manager Core', () => {
                 expect.anything(),
                 expect.anything(),
                 expect.anything(),
-                expect.anything(),
-                false
+                expect.anything()
             );
         });
     });
@@ -370,8 +356,7 @@ describe('Streaming Manager Core', () => {
                 expect.anything(),
                 expect.anything(),
                 expect.anything(),
-                expect.anything(),
-                false
+                expect.anything()
             );
 
             expect(manager.streamId).toBe('streamId');
diff --git a/src/services/streaming-manager/webrtc-manager.ts b/src/services/streaming-manager/webrtc-manager.ts
index d5416cf5..e0afde1b 100644
--- a/src/services/streaming-manager/webrtc-manager.ts
+++ b/src/services/streaming-manager/webrtc-manager.ts
@@ -198,8 +198,7 @@ export async function createWebRTCStreamingManager<T extends CreateStreamOptions
                 report,
                 streamType,
             }),
-        state => callbacks.onConnectivityStateChange?.(state),
-        warmup
+        state => callbacks.onConnectivityStateChange?.(state)
     );
 
     peerConnection.onicecandidate = (event: RTCPeerConnectionIceEvent) => {
diff --git a/src/types/entities/video.ts b/src/types/entities/video.ts
index 108c6084..6792ccac 100644
--- a/src/types/entities/video.ts
+++ b/src/types/entities/video.ts
@@ -10,6 +10,8 @@ export const mapVideoType = (type: string): VideoType => {
             return VideoType.Clip;
         case 'talk':
             return VideoType.Talk;
+        case 'expressive':
+            return VideoType.Expressive;
         default:
             throw new Error(`Unknown video type: ${type}`);
     }
diff --git a/src/types/stream/stream.ts b/src/types/stream/stream.ts
index a915e842..f8cf99a0 100644
--- a/src/types/stream/stream.ts
+++ b/src/types/stream/stream.ts
@@ -1,6 +1,7 @@
 import { Analytics } from '@sdk/services/analytics/mixpanel';
 import { VideoRTCStatsReport } from '@sdk/services/streaming-manager/stats/report';
 import { Auth } from '../auth';
+import { ChatProgressCallback } from '../entities/agents/manager';
 import { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
 import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
 
@@ -53,7 +54,7 @@ export enum StreamType {
 }
 
 export interface ManagerCallbacks {
-    onMessage?: (event: string, data: string) => void;
+    onMessage?: ChatProgressCallback;
     onConnectionStateChange?: (state: ConnectionState) => void;
     onVideoStateChange?: (state: StreamingState, report?: VideoRTCStatsReport) => void;
     onSrcObjectReady?: (value: MediaStream) => void;