main=>prod

src/services/agent-manager/connect-to-manager.test.ts

@@ -237,6 +237,7 @@ describe('connect-to-manager', () => {
         let onConnectionStateChange: (state: ConnectionState) => void;
         let onVideoStateChange: (state: StreamingState, statsReport?: any) => void;
         let onAgentActivityStateChange: (state: AgentActivityState) => void;
+        let onFirstAudioDetected: ((latency?: number) => void) | undefined;
         let onStreamReady: (() => void) | undefined;
 
         beforeEach(async () => {
@@ -249,6 +250,7 @@ describe('connect-to-manager', () => {
                 onConnectionStateChange = options.callbacks.onConnectionStateChange;
                 onVideoStateChange = options.callbacks.onVideoStateChange;
                 onAgentActivityStateChange = options.callbacks.onAgentActivityStateChange;
+                onFirstAudioDetected = options.callbacks.onFirstAudioDetected;
                 onStreamReady = options.callbacks.onStreamReady;
 
                 return new Promise(resolve => {
@@ -386,6 +388,7 @@ describe('connect-to-manager', () => {
         describe('onAgentActivityStateChange', () => {
             it('should handle agent talking state', () => {
                 onAgentActivityStateChange(AgentActivityState.Talking);
+                onFirstAudioDetected?.(1000);
 
                 expect(mockOptions.callbacks.onAgentActivityStateChange).toHaveBeenCalledWith(
                     AgentActivityState.Talking
@@ -417,6 +420,7 @@ describe('connect-to-manager', () => {
 
             it('should handle agent talking state with analytics', () => {
                 onAgentActivityStateChange(AgentActivityState.Talking);
+                onFirstAudioDetected?.(1000);
 
                 expect(mockOptions.callbacks.onAgentActivityStateChange).toHaveBeenCalledWith(
                     AgentActivityState.Talking

src/services/agent-manager/connect-to-manager.ts

@@ -107,17 +107,13 @@ function trackAgentActivityAnalytics(
     state: StreamingState,
     agent: Agent,
     analytics: Analytics,
-    streamType: StreamType
+    streamType: StreamType,
+    latency?: number
 ) {
-    if (latencyTimestampTracker.get() <= 0) return;
-
     if (state === StreamingState.Start) {
-        analytics.linkTrack(
-            'agent-video',
-            { event: 'start', latency: latencyTimestampTracker.get(true), 'stream-type': streamType },
-            'start',
-            [StreamEvents.StreamVideoCreated]
-        );
+        analytics.linkTrack('agent-video', { event: 'start', latency, 'stream-type': streamType }, 'start', [
+            StreamEvents.StreamVideoCreated,
+        ]);
     } else if (state === StreamingState.Stop) {
         analytics.linkTrack(
             'agent-video',
@@ -140,8 +136,6 @@ function trackLegacyVideoAnalytics(
     analytics: Analytics,
     streamType: StreamType
 ) {
-    if (latencyTimestampTracker.get() <= 0) return;
-
     if (state === StreamingState.Start) {
         analytics.linkTrack(
             'agent-video',
@@ -172,6 +166,7 @@ type ConnectToManagerOptions = AgentManagerOptions & {
         onMessage?: ChatProgressCallback;
         /** Internal callback for when interrupt is detected by streaming manager */
         onInterruptDetected?: (interrupt: Interrupt) => void;
+        onFirstAudioDetected?: (latency?: number) => void;
     };
     chatId?: string;
 };
@@ -195,6 +190,9 @@ function connectToManager(
                 'stream-version': streamOptions.version.toString(),
             });
 
+            let pendingStartTrack: ((latency?: number) => void) | null = null;
+            const isExpressive = agent.presenter.type === 'expressive';
+
             streamingManager = await createStreamingManager(
                 agent,
                 streamOptions,
@@ -234,16 +232,32 @@ function connectToManager(
 
                             if (state === AgentActivityState.Talking) {
                                 interruptTimestampTracker.update();
+                                pendingStartTrack = latency => {
+                                    trackAgentActivityAnalytics(
+                                        StreamingState.Start,
+                                        agent,
+                                        analytics,
+                                        streamingManager.streamType,
+                                        latency
+                                    );
+                                    pendingStartTrack = null;
+                                };
+                                if (!isExpressive) {
+                                    pendingStartTrack(latencyTimestampTracker.get(true));
+                                }
                             } else {
                                 interruptTimestampTracker.reset();
+                                pendingStartTrack = null;
+                                trackAgentActivityAnalytics(
+                                    StreamingState.Stop,
+                                    agent,
+                                    analytics,
+                                    streamingManager.streamType
+                                );
                             }
-
-                            trackAgentActivityAnalytics(
-                                state === AgentActivityState.Talking ? StreamingState.Start : StreamingState.Stop,
-                                agent,
-                                analytics,
-                                streamingManager.streamType
-                            );
+                        },
+                        onFirstAudioDetected: latency => {
+                            pendingStartTrack?.(latency);
                         },
                         onStreamReady: () => {
                             const readyLatency = streamReadyTimestampTracker.get(true);

src/services/agent-manager/index.ts

@@ -103,6 +103,8 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
     };
 
     const interrupt = ({ type }: Interrupt) => {
+        if (!items.streamingManager?.isInterruptible) return;
+
         const lastMessage = items.messages[items.messages.length - 1];
 
         analytics.track('agent-video-interrupt', {

src/services/analytics/timestamp-tracker.ts

@@ -11,3 +11,16 @@ function createTimestampTracker() {
 export const latencyTimestampTracker = createTimestampTracker();
 export const interruptTimestampTracker = createTimestampTracker();
 export const streamReadyTimestampTracker = createTimestampTracker();
+
+export const sttLatencyStore = (() => {
+    let value: number | undefined;
+    return {
+        set: (newValue: number | undefined) => {
+            value = newValue;
+        },
+        get: () => value,
+        reset: () => {
+            value = undefined;
+        },
+    };
+})();

src/services/streaming-manager/common.ts

@@ -81,6 +81,11 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      */
     interruptAvailable: boolean;
 
+    /**
+     * Whether the current stream segment can be interrupted by the user
+     */
+    isInterruptible: boolean;
+
     /**
      * Whether triggers functionality is available for this stream
      */

src/services/streaming-manager/data-channel-handlers.ts

@@ -0,0 +1,7 @@
+import { ChatProgress } from '@sdk/types/entities/agents/manager';
+import { StreamEvents } from '@sdk/types/stream';
+
+export const chatEventMap: Record<string, ChatProgress> = {
+    [StreamEvents.ChatAnswer]: ChatProgress.Answer,
+    [StreamEvents.ChatPartial]: ChatProgress.Partial,
+};