@volley/recognition-client-sdk 0.1.385 → 0.1.418

package/src/simplified-vgf-recognition-client.spec.ts

@@ -5,7 +5,7 @@
 import { SimplifiedVGFRecognitionClient, createSimplifiedVGFClient } from './simplified-vgf-recognition-client.js';
 import { RealTimeTwoWayWebSocketRecognitionClient } from './recognition-client.js';
 import { ClientState } from './recognition-client.types.js';
-import { AudioEncoding, RecognitionContextTypeV1 } from '@recog/shared-types';
+import { AudioEncoding, RecognitionContextTypeV1, RecognitionResultTypeV1 } from '@recog/shared-types';
 import {
   RecordingStatus,
   TranscriptionStatus,
@@ -287,21 +287,43 @@ describe('SimplifiedVGFRecognitionClient', () => {
       expect(updatedState.finalTranscriptionTimestamp).toBeDefined();
     });
 
-    it('should handle metadata and mark recording as finished', () => {
+    it('should pass metadata to callback without updating VGF state', () => {
       // Get the actual UUID from the client
       const actualUuid = simplifiedClient.getVGFState().audioUtteranceId;
+      const originalOnMetadata = jest.fn();
 
+      // Create new client with onMetadata callback
+      const clientWithMetadata = new SimplifiedVGFRecognitionClient({
+        asrRequestConfig: {
+          provider: 'deepgram',
+          language: 'en',
+          sampleRate: 16000,
+          encoding: AudioEncoding.LINEAR16
+        },
+        onStateChange: stateChangeCallback,
+        onMetadata: originalOnMetadata
+      });
+
+      const constructorCalls = (RealTimeTwoWayWebSocketRecognitionClient as jest.MockedClass<typeof RealTimeTwoWayWebSocketRecognitionClient>).mock.calls;
+      const latestConfig = constructorCalls[constructorCalls.length - 1]?.[0];
+      const metadataCallback = latestConfig?.onMetadata;
+
+      const clientUuid = clientWithMetadata.getVGFState().audioUtteranceId;
       const metadata = {
-        audioUtteranceId: actualUuid,
-        duration: 5000
+        type: RecognitionResultTypeV1.METADATA as const,
+        audioUtteranceId: clientUuid
       };
 
-      onMetadataCallback(metadata);
+      // Clear previous state changes from client creation
+      stateChangeCallback.mockClear();
 
-      expect(stateChangeCallback).toHaveBeenCalled();
-      const updatedState = stateChangeCallback.mock.calls[0][0];
-      expect(updatedState.startRecordingStatus).toBe(RecordingStatus.FINISHED);
-      expect(updatedState.finalRecordingTimestamp).toBeDefined();
+      metadataCallback?.(metadata);
+
+      // Metadata should NOT trigger state change (state management simplified)
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+
+      // But original callback should still be called
+      expect(originalOnMetadata).toHaveBeenCalledWith(metadata);
     });
 
     it('should handle errors and update state', () => {
@@ -325,13 +347,18 @@ describe('SimplifiedVGFRecognitionClient', () => {
       // Then error occurs
       onErrorCallback({ message: 'Error' });
 
-      // Send audio again should restart recording
+      // After terminal status (ERROR), no more state changes should be emitted
+      // The session is considered over, so sendAudio should not trigger callbacks
       stateChangeCallback.mockClear();
       simplifiedClient.sendAudio(Buffer.from([4, 5, 6]));
 
-      const updatedState = stateChangeCallback.mock.calls[0][0];
-      expect(updatedState.startRecordingStatus).toBe(RecordingStatus.RECORDING);
-      expect(updatedState.startRecordingTimestamp).toBeDefined();
+      // No callback should be triggered since we're in terminal state
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+
+      // However, the internal isRecordingAudio flag should still be reset
+      // (verified by the fact that the flag was set during the first sendAudio)
+      const state = simplifiedClient.getVGFState();
+      expect(state.transcriptionStatus).toBe(TranscriptionStatus.ERROR);
     });
   });
 
@@ -1331,4 +1358,163 @@ describe('SimplifiedVGFRecognitionClient', () => {
       expect(stateChangeCallback).not.toHaveBeenCalled();
     });
   });
+
+  describe('Terminal Status Protection', () => {
+    let stateChangeCallback: jest.Mock;
+    let onTranscriptCallback: (result: any) => void;
+    let onErrorCallback: (error: any) => void;
+    let simplifiedClient: SimplifiedVGFRecognitionClient;
+    let clientUuid: string;
+
+    beforeEach(() => {
+      stateChangeCallback = jest.fn();
+      simplifiedClient = new SimplifiedVGFRecognitionClient({
+        asrRequestConfig: {
+          provider: 'deepgram',
+          language: 'en',
+          sampleRate: 16000,
+          encoding: AudioEncoding.LINEAR16
+        },
+        onStateChange: stateChangeCallback
+      });
+
+      const constructorCalls = (RealTimeTwoWayWebSocketRecognitionClient as jest.MockedClass<typeof RealTimeTwoWayWebSocketRecognitionClient>).mock.calls;
+      const latestConfig = constructorCalls[constructorCalls.length - 1]?.[0];
+      onTranscriptCallback = latestConfig?.onTranscript ?? jest.fn();
+      onErrorCallback = latestConfig?.onError ?? jest.fn();
+      clientUuid = simplifiedClient.getVGFState().audioUtteranceId;
+    });
+
+    it('should allow first terminal transcript callback', () => {
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'hello',
+        finalTranscriptConfidence: 0.9,
+        is_finished: true
+      });
+
+      expect(stateChangeCallback).toHaveBeenCalledTimes(1);
+      expect(stateChangeCallback.mock.calls[0][0].transcriptionStatus).toBe(TranscriptionStatus.FINALIZED);
+    });
+
+    it('should block second terminal transcript callback with same UUID', () => {
+      // First terminal
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'first',
+        finalTranscriptConfidence: 0.9,
+        is_finished: true
+      });
+
+      stateChangeCallback.mockClear();
+
+      // Second terminal - should be blocked
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'second',
+        finalTranscriptConfidence: 0.95,
+        is_finished: true
+      });
+
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+    });
+
+    it('should allow first error callback', () => {
+      onErrorCallback({
+        audioUtteranceId: clientUuid,
+        message: 'Error occurred'
+      });
+
+      expect(stateChangeCallback).toHaveBeenCalledTimes(1);
+      expect(stateChangeCallback.mock.calls[0][0].transcriptionStatus).toBe(TranscriptionStatus.ERROR);
+    });
+
+    it('should block second error callback with same UUID', () => {
+      // First error
+      onErrorCallback({
+        audioUtteranceId: clientUuid,
+        message: 'First error'
+      });
+
+      stateChangeCallback.mockClear();
+
+      // Second error - should be blocked
+      onErrorCallback({
+        audioUtteranceId: clientUuid,
+        message: 'Second error'
+      });
+
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+    });
+
+    it('should block transcript after error', () => {
+      // Error first
+      onErrorCallback({
+        audioUtteranceId: clientUuid,
+        message: 'Error'
+      });
+
+      stateChangeCallback.mockClear();
+
+      // Transcript after error - should be blocked
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'late',
+        finalTranscriptConfidence: 0.9,
+        is_finished: true
+      });
+
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+    });
+
+    it('should block error after terminal transcript', () => {
+      // Terminal transcript first
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'done',
+        finalTranscriptConfidence: 0.9,
+        is_finished: true
+      });
+
+      stateChangeCallback.mockClear();
+
+      // Error after terminal - should be blocked
+      onErrorCallback({
+        audioUtteranceId: clientUuid,
+        message: 'Late error'
+      });
+
+      expect(stateChangeCallback).not.toHaveBeenCalled();
+    });
+
+    it('should preserve original state after blocking duplicate', () => {
+      // First terminal with specific transcript
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'original',
+        finalTranscriptConfidence: 0.85,
+        is_finished: true
+      });
+
+      // Attempt second terminal with different transcript
+      onTranscriptCallback({
+        type: 'Transcription',
+        audioUtteranceId: clientUuid,
+        finalTranscript: 'different',
+        finalTranscriptConfidence: 0.99,
+        is_finished: true
+      });
+
+      // State should still have original values
+      const state = simplifiedClient.getVGFState();
+      expect(state.finalTranscript).toBe('original');
+      expect(state.finalConfidence).toBe(0.85);
+    });
+  });
 });

package/src/simplified-vgf-recognition-client.ts

@@ -24,10 +24,10 @@ import {
     createVGFStateFromConfig,
     mapTranscriptionResultToState,
     mapErrorToState,
-    updateStateOnStop
+    updateStateOnStop,
+    resetSessionState
 } from './vgf-recognition-mapper.js';
 import { RecognitionContextTypeV1 } from '@recog/shared-types';
-import { v4 as uuidv4 } from 'uuid';
 
 /**
  * Configuration for SimplifiedVGFRecognitionClient
@@ -153,6 +153,7 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
     private stateChangeCallback: ((state: RecognitionState) => void) | undefined;
     private expectedUuid: string;
     private logger: IRecognitionClientConfig['logger'];
+    private lastSentTerminalUuid: string | null = null;
 
     constructor(config: SimplifiedVGFClientConfig) {
         const { onStateChange, initialState, ...clientConfig } = config;
@@ -169,8 +170,9 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
                                 initialState.transcriptionStatus === TranscriptionStatus.ERROR ||
                                 (initialState.recognitionActionProcessingState !== undefined && initialState.recognitionActionProcessingState !== RecognitionActionProcessingState.COMPLETED);
             if (needsNewUuid) {
-                // Generate new UUID for fresh session
-                const newUUID = uuidv4();
+                // Reset session state with new UUID
+                this.state = resetSessionState(initialState);
+                const newUUID = this.state.audioUtteranceId;
 
                 if (clientConfig.logger) {
                     const reason = !initialState.audioUtteranceId ? 'Missing UUID' :
@@ -179,19 +181,12 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
                     clientConfig.logger('info', `${reason} detected, generating new UUID: ${newUUID}`);
                 }
 
-                // Update state with new UUID and reset session-specific fields
-                this.state = {
-                    ...initialState,
-                    audioUtteranceId: newUUID,
-                    transcriptionStatus: TranscriptionStatus.NOT_STARTED,
-                    startRecordingStatus: RecordingStatus.READY,
-                    recognitionActionProcessingState: RecognitionActionProcessingState.NOT_STARTED,
-                    finalTranscript: undefined
-                };
-
                 // Use new UUID in client config
                 clientConfig.audioUtteranceId = newUUID;
 
+                // Reset terminal status tracking for new session
+                this.lastSentTerminalUuid = null;
+
                 // Notify state change immediately so app can update
                 if (onStateChange) {
                     onStateChange(this.state);
@@ -245,12 +240,19 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
                 if (result.audioUtteranceId && result.audioUtteranceId !== this.expectedUuid) {
                     if (this.logger) {
                         this.logger('warn',
-                            `[VGF] Skipping transcript update: UUID mismatch (expected: ${this.expectedUuid}, got: ${result.audioUtteranceId})`
+                            `[RecogSDK:VGF] Skipping transcript update: UUID mismatch (expected: ${this.expectedUuid}, got: ${result.audioUtteranceId})`
                         );
                     }
-                    // Still call original callback if provided
-                    if (clientConfig.onTranscript) {
-                        clientConfig.onTranscript(result);
+                    return;
+                }
+
+                // Skip if terminal status already sent for THIS session
+                // (If lastSentTerminalUuid exists but doesn't match expectedUuid, treat as new session)
+                if (this.lastSentTerminalUuid === this.expectedUuid) {
+                    if (this.logger) {
+                        this.logger('info',
+                            `[RecogSDK:VGF] Duplicate terminal status suppressed (lastSentTerminalUuid: ${this.lastSentTerminalUuid})`
+                        );
                     }
                     return;
                 }
@@ -270,7 +272,7 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
                 if (metadata.audioUtteranceId && metadata.audioUtteranceId !== this.expectedUuid) {
                     if (this.logger) {
                         this.logger('warn',
-                            `[VGF] Skipping metadata update: UUID mismatch (expected: ${this.expectedUuid}, got: ${metadata.audioUtteranceId})`
+                            `[RecogSDK:VGF] Skipping metadata update: UUID mismatch (expected: ${this.expectedUuid}, got: ${metadata.audioUtteranceId})`
                         );
                     }
                     return;
@@ -293,12 +295,17 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
                 if (error.audioUtteranceId && error.audioUtteranceId !== this.expectedUuid) {
                     if (this.logger) {
                         this.logger('warn',
-                            `[VGF] Skipping error update: UUID mismatch (expected: ${this.expectedUuid}, got: ${error.audioUtteranceId})`
+                            `[RecogSDK:VGF] Skipping error update: UUID mismatch (expected: ${this.expectedUuid}, got: ${error.audioUtteranceId})`
                         );
                     }
                     return;
                 }
 
+                // Skip if terminal status already sent for THIS session
+                if (this.lastSentTerminalUuid === this.expectedUuid) {
+                    return;
+                }
+
                 this.isRecordingAudio = false; // Reset on error
                 this.state = mapErrorToState(this.state, error);
                 this.notifyStateChange();
@@ -350,6 +357,27 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
         this.isRecordingAudio = false;
         this.state = updateStateOnStop(this.state);
         this.notifyStateChange();
+
+        // Early termination: If transcription never started (NOT_STARTED), emit synthetic finalization immediately
+        // This prevents games from getting stuck waiting for a server response that may never come
+        if (this.state.transcriptionStatus === TranscriptionStatus.NOT_STARTED) {
+            if (this.logger) {
+                this.logger('info',
+                    `[RecogSDK:VGF] Early termination detected (transcriptionStatus: NOT_STARTED) - emitting synthetic finalization`
+                );
+            }
+            this.state = {
+                ...this.state,
+                transcriptionStatus: TranscriptionStatus.FINALIZED,
+                finalTranscript: '',
+                finalConfidence: 0,
+                pendingTranscript: '',
+                pendingConfidence: undefined,
+                finalTranscriptionTimestamp: new Date().toISOString()
+            };
+            this.notifyStateChange();
+        }
+
         await this.client.stopRecording();
     }
 
@@ -424,11 +452,34 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
         return { ...this.state };
     }
 
+    private isTerminalStatus(status: string | undefined): boolean {
+        return status === TranscriptionStatus.FINALIZED ||
+               status === TranscriptionStatus.ABORTED ||
+               status === TranscriptionStatus.ERROR;
+    }
+
     private notifyStateChange(): void {
-        // State has already been validated for correct UUID before this is called
-        if (this.stateChangeCallback) {
-            this.stateChangeCallback({ ...this.state });
+
+        // Block duplicate terminal status emissions for THIS session
+        if (this.isTerminalStatus(this.state.transcriptionStatus)) {
+            if (this.lastSentTerminalUuid === this.expectedUuid) {
+                // Already sent a terminal status for this session - suppress duplicate
+                if (this.logger) {
+                    this.logger('info',
+                        `[RecogSDK:VGF] Duplicate terminal status suppressed (lastSentTerminalUuid: ${this.lastSentTerminalUuid})`
+                    );
+                }
+                return;
+            }
+            // First terminal status for this session - record it
+            this.lastSentTerminalUuid = this.expectedUuid;
         }
+        
+        if (!this.stateChangeCallback) {
+            return;
+        }        
+
+        this.stateChangeCallback({ ...this.state });
     }
 }
 
@@ -477,4 +528,4 @@ export class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRecognition
  */
 export function createSimplifiedVGFClient(config: SimplifiedVGFClientConfig): ISimplifiedVGFRecognitionClient {
     return new SimplifiedVGFRecognitionClient(config);
-}
+}

package/src/utils/audio-ring-buffer.ts

@@ -55,7 +55,7 @@ export class AudioRingBuffer {
 
       // Log buffer overflow event
       if (this.logger) {
-        this.logger('debug', 'Buffer overflow detected', {
+        this.logger('debug', '[RecogSDK] Buffer overflow detected', {
           bufferSize: this.bufferSize,
           totalOverflows: this.overflowCount,
           droppedChunk: this.buffer[this.readIndex]?.timestamp
@@ -151,7 +151,7 @@ export class AudioRingBuffer {
     this.totalBufferedBytes = 0;
 
     if (this.logger) {
-      this.logger('debug', 'Audio buffer cleared');
+      this.logger('debug', '[RecogSDK] Audio buffer cleared');
     }
   }
 

package/src/utils/message-handler.ts

@@ -44,7 +44,7 @@ export class MessageHandler {
   handleMessage(msg: { v: number; type: string; data: any }): void {
     // Log ALL incoming messages for debugging
     if (this.callbacks.logger) {
-      this.callbacks.logger('debug', 'Received WebSocket message', {
+      this.callbacks.logger('debug', '[RecogSDK] Received WebSocket message', {
         msgType: msg.type,
         msgDataType: msg.data && typeof msg.data === 'object' && 'type' in msg.data ? msg.data.type : 'N/A',
         fullMessage: msg
@@ -55,7 +55,7 @@ export class MessageHandler {
     // Log error if we receive primitive data (indicates server issue)
     if (msg.data && typeof msg.data !== 'object') {
       if (this.callbacks.logger) {
-        this.callbacks.logger('error', 'Received primitive msg.data from server', {
+        this.callbacks.logger('error', '[RecogSDK] Received primitive msg.data from server', {
           dataType: typeof msg.data,
           data: msg.data,
           fullMessage: msg
@@ -90,7 +90,7 @@ export class MessageHandler {
       default:
         // Unknown message type - log if logger available
         if (this.callbacks.logger) {
-          this.callbacks.logger('debug', 'Unknown message type', { type: msgType });
+          this.callbacks.logger('debug', '[RecogSDK] Unknown message type', { type: msgType });
         }
     }
   }
@@ -106,7 +106,7 @@ export class MessageHandler {
       const timeToFirstTranscript = this.firstTranscriptTime - this.sessionStartTime;
 
       if (this.callbacks.logger) {
-        this.callbacks.logger('debug', 'First transcript received', {
+        this.callbacks.logger('debug', '[RecogSDK] First transcript received', {
           timeToFirstTranscriptMs: timeToFirstTranscript
         });
       }

package/src/utils/url-builder.ts

@@ -19,6 +19,8 @@ export interface UrlBuilderConfig {
   questionAnswerId?: string;
   platform?: string;
   gameContext?: GameContextV1;
+  /** Standalone gameId - takes precedence over gameContext.gameId if both provided */
+  gameId?: string;
 }
 
 /**
@@ -75,9 +77,14 @@ export function buildWebSocketUrl(config: UrlBuilderConfig): string {
     url.searchParams.set('platform', config.platform);
   }
 
-  // Add gameId and gamePhase if provided from gameContext
-  if (config.gameContext) {
-    url.searchParams.set('gameId', config.gameContext.gameId);
+  // Add gameId - standalone gameId takes precedence over gameContext.gameId
+  const gameId = config.gameId ?? config.gameContext?.gameId;
+  if (gameId) {
+    url.searchParams.set('gameId', gameId);
+  }
+
+  // Add gamePhase from gameContext if provided
+  if (config.gameContext?.gamePhase) {
     url.searchParams.set('gamePhase', config.gameContext.gamePhase);
   }
 

package/src/vgf-recognition-mapper.spec.ts

@@ -0,0 +1,78 @@
+/**
+ * Unit tests for VGF Recognition Mapper functions
+ */
+
+import {
+    resetSessionState
+} from './vgf-recognition-mapper.js';
+import {
+    RecognitionState,
+    RecordingStatus,
+    TranscriptionStatus,
+    RecognitionActionProcessingState
+} from './vgf-recognition-state.js';
+
+describe('resetSessionState', () => {
+    it('should generate a new UUID', () => {
+        const originalState: RecognitionState = {
+            audioUtteranceId: 'old-uuid-123',
+            pendingTranscript: '',
+            transcriptionStatus: TranscriptionStatus.FINALIZED,
+            startRecordingStatus: RecordingStatus.FINISHED,
+            recognitionActionProcessingState: RecognitionActionProcessingState.COMPLETED,
+            finalTranscript: 'hello world'
+        };
+
+        const newState = resetSessionState(originalState);
+
+        expect(newState.audioUtteranceId).not.toBe('old-uuid-123');
+        expect(newState.audioUtteranceId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+    });
+
+    it('should reset session-specific fields', () => {
+        const originalState: RecognitionState = {
+            audioUtteranceId: 'old-uuid-123',
+            pendingTranscript: 'partial',
+            transcriptionStatus: TranscriptionStatus.FINALIZED,
+            startRecordingStatus: RecordingStatus.FINISHED,
+            recognitionActionProcessingState: RecognitionActionProcessingState.COMPLETED,
+            finalTranscript: 'hello world'
+        };
+
+        const newState = resetSessionState(originalState);
+
+        expect(newState.transcriptionStatus).toBe(TranscriptionStatus.NOT_STARTED);
+        expect(newState.startRecordingStatus).toBe(RecordingStatus.READY);
+        expect(newState.recognitionActionProcessingState).toBe(RecognitionActionProcessingState.NOT_STARTED);
+        expect(newState.finalTranscript).toBeUndefined();
+    });
+
+    it('should preserve non-session fields like promptSlotMap', () => {
+        const originalState: RecognitionState = {
+            audioUtteranceId: 'old-uuid-123',
+            pendingTranscript: '',
+            transcriptionStatus: TranscriptionStatus.FINALIZED,
+            promptSlotMap: { artist: ['taylor swift'], song: ['shake it off'] },
+            asrConfig: '{"provider":"deepgram"}'
+        };
+
+        const newState = resetSessionState(originalState);
+
+        expect(newState.promptSlotMap).toEqual({ artist: ['taylor swift'], song: ['shake it off'] });
+        expect(newState.asrConfig).toBe('{"provider":"deepgram"}');
+    });
+
+    it('should work with minimal state', () => {
+        const originalState: RecognitionState = {
+            audioUtteranceId: 'old-uuid',
+            pendingTranscript: ''
+        };
+
+        const newState = resetSessionState(originalState);
+
+        expect(newState.audioUtteranceId).not.toBe('old-uuid');
+        expect(newState.transcriptionStatus).toBe(TranscriptionStatus.NOT_STARTED);
+        expect(newState.startRecordingStatus).toBe(RecordingStatus.READY);
+        expect(newState.recognitionActionProcessingState).toBe(RecognitionActionProcessingState.NOT_STARTED);
+    });
+});

package/src/vgf-recognition-mapper.ts

@@ -9,8 +9,10 @@ import {
     RecognitionState,
     RecordingStatus,
     TranscriptionStatus,
+    RecognitionActionProcessingState,
     createInitialRecognitionState
 } from './vgf-recognition-state.js';
+import { v4 as uuidv4 } from 'uuid';
 import {
     ClientState,
     IRecognitionClientConfig
@@ -142,6 +144,33 @@ export function updateStateOnStop(currentState: RecognitionState): RecognitionSt
     };
 }
 
+/**
+ * Resets session state with a new UUID.
+ * 
+ * This creates a fresh session state while preserving non-session fields
+ * (like promptSlotMap, asrConfig, etc.)
+ * 
+ * Resets:
+ * - audioUtteranceId → new UUID
+ * - transcriptionStatus → NOT_STARTED
+ * - startRecordingStatus → READY
+ * - recognitionActionProcessingState → NOT_STARTED
+ * - finalTranscript → undefined
+ * 
+ * @param currentState - The current recognition state
+ * @returns A new state with reset session fields and a new UUID
+ */
+export function resetSessionState(currentState: RecognitionState): RecognitionState {
+    return {
+        ...currentState,
+        audioUtteranceId: uuidv4(),
+        transcriptionStatus: TranscriptionStatus.NOT_STARTED,
+        startRecordingStatus: RecordingStatus.READY,
+        recognitionActionProcessingState: RecognitionActionProcessingState.NOT_STARTED,
+        finalTranscript: undefined
+    };
+}
+
 /**
  * Updates state when client becomes ready
  */