@volley/recognition-client-sdk 0.1.287 → 0.1.295

package/dist/recognition-client.d.ts

@@ -88,6 +88,7 @@ export declare class RealTimeTwoWayWebSocketRecognitionClient extends WebSocketA
     sendAudio(audioData: ArrayBuffer | ArrayBufferView | Blob): void;
     private sendAudioInternal;
     stopRecording(): Promise<void>;
+    stopAbnormally(): void;
     getAudioUtteranceId(): string;
     getUrl(): string;
     getState(): ClientState;

package/dist/recognition-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognition-client.d.ts","sourceRoot":"","sources":["../src/recognition-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAML,KAAK,qBAAqB,EAS3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,KAAK,EACV,kBAAkB,EAClB,uBAAuB,EACvB,8CAA8C,EAE/C,MAAM,+BAA+B,CAAC;AAUvC;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D;AAgCD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,qBAAqB,CAAC;AAGxD,YAAY,EAAE,8CAA8C,EAAE,MAAM,+BAA+B,CAAC;AAgCpG;;;;;GAKG;AACH,qBAAa,wCACX,SAAQ,oBAAoB,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,CAC7C,YAAW,kBAAkB;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAE7C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,iBAAiB,CAA4B;IAGrD,OAAO,CAAC,iBAAiB,CAAS;IAGlC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,qBAAqB,CAAO;IACpC,OAAO,CAAC,iBAAiB,CAAK;gBAElB,MAAM,EAAE,8CAA8C;IA8ElE;;;;;;OAMG;IACH,OAAO,CAAC,GAAG;IAWX;;;OAGG;IACH,OAAO,CAAC,OAAO;IAmBA,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA6BvC;;;OAGG;YACW,gBAAgB;IAkIrB,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI;IAiBzE,OAAO,CAAC,iBAAiB;IAsCnB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAqCpC,mBAAmB,IAAI,MAAM;IAI7B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,WAAW;IAIvB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,OAAO;IAIvB,UAAU,IAAI,OAAO;IAIrB,uBAAuB,IAAI,OAAO;IAIlC,mBAAmB,IAAI,OAAO;IAI9B,QAAQ,IAAI,uBAAuB;IAgBnC,SAAS,CAAC,WAAW,IAAI,IAAI;IAiE7B,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAqB5D,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;cAYlB,SAAS,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI;IAQ/E;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;;OAGG;IACH,OAAO,CAAC,YAAY;CAuBrB"}
+{"version":3,"file":"recognition-client.d.ts","sourceRoot":"","sources":["../src/recognition-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAML,KAAK,qBAAqB,EAS3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,KAAK,EACV,kBAAkB,EAClB,uBAAuB,EACvB,8CAA8C,EAE/C,MAAM,+BAA+B,CAAC;AAUvC;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D;AAgCD;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,qBAAqB,CAAC;AAGxD,YAAY,EAAE,8CAA8C,EAAE,MAAM,+BAA+B,CAAC;AAgCpG;;;;;GAKG;AACH,qBAAa,wCACX,SAAQ,oBAAoB,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,CAC7C,YAAW,kBAAkB;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAE7C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,iBAAiB,CAA4B;IAGrD,OAAO,CAAC,iBAAiB,CAAS;IAGlC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,qBAAqB,CAAO;IACpC,OAAO,CAAC,iBAAiB,CAAK;gBAElB,MAAM,EAAE,8CAA8C;IA8ElE;;;;;;OAMG;IACH,OAAO,CAAC,GAAG;IAWX;;;OAGG;IACH,OAAO,CAAC,OAAO;IAmBA,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA6BvC;;;OAGG;YACW,gBAAgB;IAkIrB,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI;IAiBzE,OAAO,CAAC,iBAAiB;IAsCnB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCpC,cAAc,IAAI,IAAI;IAwBtB,mBAAmB,IAAI,MAAM;IAI7B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,WAAW;IAIvB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,OAAO;IAIvB,UAAU,IAAI,OAAO;IAIrB,uBAAuB,IAAI,OAAO;IAIlC,mBAAmB,IAAI,OAAO;IAI9B,QAAQ,IAAI,uBAAuB;IAgBnC,SAAS,CAAC,WAAW,IAAI,IAAI;IAiE7B,SAAS,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAqB5D,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;cAYlB,SAAS,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI;IAQ/E;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;;OAGG;IACH,OAAO,CAAC,YAAY;CAuBrB"}

package/dist/recognition-client.types.d.ts

@@ -172,6 +172,24 @@ export interface IRecognitionClient {
      * @returns Promise that resolves when final transcript is received
      */
     stopRecording(): Promise<void>;
+    /**
+     * Force stop and immediately close connection without waiting for server
+     *
+     * WARNING: This is an abnormal shutdown that bypasses the graceful stop flow:
+     * - Does NOT wait for server to process remaining audio
+     * - Does NOT receive final transcript from server
+     * - Immediately closes WebSocket connection
+     * - Cleans up resources (buffers, listeners)
+     *
+     * Use Cases:
+     * - User explicitly cancels/abandons session
+     * - Timeout scenarios where waiting is not acceptable
+     * - Need immediate cleanup and can't wait for server
+     *
+     * RECOMMENDED: Use stopRecording() for normal shutdown.
+     * Only use this when immediate disconnection is required.
+     */
+    stopAbnormally(): void;
     /**
      * Get the audio utterance ID for this session
      * Available immediately after client construction.

package/dist/recognition-client.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognition-client.types.d.ts","sourceRoot":"","sources":["../src/recognition-client.types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recognition-client.types.d.ts","sourceRoot":"","sources":["../src/recognition-client.types.ts"],"names":[],"mappings":"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"}

package/dist/simplified-vgf-recognition-client.d.ts

@@ -46,6 +46,24 @@ export interface ISimplifiedVGFRecognitionClient {
      * @returns Promise that resolves when transcription is complete
      */
     stopRecording(): Promise<void>;
+    /**
+     * Force stop and immediately close connection without waiting for server
+     *
+     * WARNING: This is an abnormal shutdown that bypasses the graceful stop flow:
+     * - Does NOT wait for server to process remaining audio
+     * - Does NOT receive final transcript from server (VGF state set to empty)
+     * - Immediately closes WebSocket connection
+     * - Cleans up resources (buffers, listeners)
+     *
+     * Use Cases:
+     * - User explicitly cancels/abandons the session
+     * - Timeout scenarios where waiting is not acceptable
+     * - Need immediate cleanup and can't wait for server
+     *
+     * RECOMMENDED: Use stopRecording() for normal shutdown.
+     * Only use this when immediate disconnection is required.
+     */
+    stopAbnormally(): void;
     /**
      * Get the current VGF recognition state
      * @returns Current RecognitionState with all transcription data
@@ -97,6 +115,7 @@ export declare class SimplifiedVGFRecognitionClient implements ISimplifiedVGFRec
     connect(): Promise<void>;
     sendAudio(audioData: ArrayBuffer | ArrayBufferView | Blob): void;
     stopRecording(): Promise<void>;
+    stopAbnormally(): void;
     getAudioUtteranceId(): string;
     getUrl(): string;
     getState(): ClientState;

package/dist/simplified-vgf-recognition-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplified-vgf-recognition-client.d.ts","sourceRoot":"","sources":["../src/simplified-vgf-recognition-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAEH,wBAAwB,EACxB,WAAW,EACd,MAAM,+BAA+B,CAAC;AAWvC;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;IACvE;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAElD;;;OAGG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,+BAA+B;IAE5C;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;OAGG;IACH,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;IAEjE;;;OAGG;IACH,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAG/B;;;OAGG;IACH,WAAW,IAAI,gBAAgB,CAAC;IAGhC;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC;IAEvB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAC;IAExB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC;IAEtB;;OAEG;IACH,uBAAuB,IAAI,OAAO,CAAC;IAEnC;;OAEG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAG/B;;OAEG;IACH,mBAAmB,IAAI,MAAM,CAAC;IAE9B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,IAAI,WAAW,CAAC;CAE3B;AAED;;;GAGG;AACH,qBAAa,8BAA+B,YAAW,+BAA+B;IAClF,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,mBAAmB,CAAkD;gBAEjE,MAAM,EAAE,yBAAyB;IAoGvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI;IAc1D,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAQpC,mBAAmB,IAAI,MAAM;IAI7B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,WAAW;IAIvB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,OAAO;IAIvB,UAAU,IAAI,OAAO;IAIrB,uBAAuB,IAAI,OAAO;IAIlC,mBAAmB,IAAI,OAAO;IAM9B,WAAW,IAAI,gBAAgB;IAI/B,OAAO,CAAC,iBAAiB;CAK5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,+BAA+B,CAE5G"}
+{"version":3,"file":"simplified-vgf-recognition-client.d.ts","sourceRoot":"","sources":["../src/simplified-vgf-recognition-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACH,gBAAgB,EAGnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEH,wBAAwB,EACxB,WAAW,EACd,MAAM,+BAA+B,CAAC;AAWvC;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;IACvE;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAElD;;;OAGG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,+BAA+B;IAE5C;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;OAGG;IACH,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;IAEjE;;;OAGG;IACH,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,IAAI,IAAI,CAAC;IAGvB;;;OAGG;IACH,WAAW,IAAI,gBAAgB,CAAC;IAGhC;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC;IAEvB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAC;IAExB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC;IAEtB;;OAEG;IACH,uBAAuB,IAAI,OAAO,CAAC;IAEnC;;OAEG;IACH,mBAAmB,IAAI,OAAO,CAAC;IAG/B;;OAEG;IACH,mBAAmB,IAAI,MAAM,CAAC;IAE9B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,IAAI,WAAW,CAAC;CAE3B;AAED;;;GAGG;AACH,qBAAa,8BAA+B,YAAW,+BAA+B;IAClF,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,mBAAmB,CAAkD;gBAEjE,MAAM,EAAE,yBAAyB;IAoGvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,IAAI;IAc1D,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC,cAAc,IAAI,IAAI;IAiCtB,mBAAmB,IAAI,MAAM;IAI7B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,WAAW;IAIvB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,OAAO;IAIvB,UAAU,IAAI,OAAO;IAIrB,uBAAuB,IAAI,OAAO;IAIlC,mBAAmB,IAAI,OAAO;IAM9B,WAAW,IAAI,gBAAgB;IAI/B,OAAO,CAAC,iBAAiB;CAK5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,+BAA+B,CAE5G"}

package/dist/vgf-recognition-state.d.ts

@@ -73,6 +73,7 @@ export declare const TranscriptionStatus: {
     readonly NOT_STARTED: "NOT_STARTED";
     readonly IN_PROGRESS: "IN_PROGRESS";
     readonly FINALIZED: "FINALIZED";
+    readonly ABORTED: "ABORTED";
     readonly ERROR: "ERROR";
 };
 export type TranscriptionStatusType = typeof TranscriptionStatus[keyof typeof TranscriptionStatus];

package/dist/vgf-recognition-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgf-recognition-state.d.ts","sourceRoot":"","sources":["../src/vgf-recognition-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BpC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAGxE,eAAO,MAAM,eAAe;;;;;CAKlB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,OAAO,eAAe,CAAC,MAAM,OAAO,eAAe,CAAC,CAAA;AAEtF,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAAG,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAA;AAGlG,wBAAgB,6BAA6B,CAAC,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAOxF;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAa9F"}
+{"version":3,"file":"vgf-recognition-state.d.ts","sourceRoot":"","sources":["../src/vgf-recognition-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BpC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAGxE,eAAO,MAAM,eAAe;;;;;CAKlB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,OAAO,eAAe,CAAC,MAAM,OAAO,eAAe,CAAC,CAAA;AAEtF,eAAO,MAAM,mBAAmB;;;;;;CAMtB,CAAA;AAEV,MAAM,MAAM,uBAAuB,GAAG,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAA;AAGlG,wBAAgB,6BAA6B,CAAC,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAOxF;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAa9F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volley/recognition-client-sdk",
-  "version": "0.1.287",
+  "version": "0.1.295",
   "description": "Recognition Service TypeScript/Node.js Client SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -53,8 +53,8 @@
     "ts-jest": "^29.4.5",
     "typescript": "^5.1.6",
     "@recog/shared-config": "1.0.0",
-    "@recog/shared-utils": "1.0.0",
     "@recog/shared-types": "1.0.0",
+    "@recog/shared-utils": "1.0.0",
     "@recog/websocket": "1.0.0"
   },
   "keywords": [

package/src/recognition-client.spec.ts

@@ -4,6 +4,7 @@
 
 import { RealTimeTwoWayWebSocketRecognitionClient } from './recognition-client';
 import { ClientState } from './recognition-client.types';
+import { RecognitionResultTypeV1 } from '@recog/shared-types';
 import { WebSocket as MockWebSocket } from 'ws';
 
 // Mock WebSocket
@@ -752,7 +753,11 @@ describe('RealTimeTwoWayWebSocketRecognitionClient', () => {
   async function setupConnectedClient() {
     const connectPromise = client.connect();
     mockWs.readyState = MockWebSocket.OPEN;
-    const openHandler = mockWs.on.mock.calls.find((call: any[]) => call[0] === 'open')[1];
+    const openCall = mockWs.on.mock.calls.find((call: any[]) => call[0] === 'open');
+    if (!openCall) {
+      throw new Error('No "open" event handler registered on mockWs');
+    }
+    const openHandler = openCall[1];
     openHandler();
     await connectPromise;
   }
@@ -771,4 +776,114 @@ describe('RealTimeTwoWayWebSocketRecognitionClient', () => {
     });
     messageHandler(readyMessage);
   }
+
+  describe('stopAbnormally', () => {
+    beforeEach(() => {
+      // Create fresh mock WebSocket
+      mockWs = {
+        readyState: MockWebSocket.CONNECTING,
+        send: jest.fn(),
+        close: jest.fn(),
+        on: jest.fn().mockReturnThis(),
+        removeAllListeners: jest.fn(),
+      };
+
+      // Mock WebSocket constructor
+      (MockWebSocket as any).mockImplementation(() => mockWs);
+
+      // Create fresh client
+      client = new RealTimeTwoWayWebSocketRecognitionClient({
+        url: 'ws://localhost:3000',
+        asrRequestConfig: {
+          provider: 'deepgram',
+          language: 'en',
+          sampleRate: 16000,
+          encoding: 'linear16'
+        },
+        onTranscript: jest.fn(),
+        onError: jest.fn(),
+        onConnected: jest.fn(),
+        onDisconnected: jest.fn()
+      });
+    });
+
+    it.skip('should immediately close WebSocket connection', async () => {
+      await setupReadyClient();
+      expect(client.getState()).toBe(ClientState.READY);
+
+      client.stopAbnormally();
+
+      expect(mockWs.close).toHaveBeenCalledWith(1000, 'Client abnormal stop');
+    });
+
+    it.skip('should update state to STOPPED', async () => {
+      await setupReadyClient();
+
+      client.stopAbnormally();
+
+      expect(client.getState()).toBe(ClientState.STOPPED);
+    });
+
+    it('should work from any state', () => {
+      // Test from INITIAL state
+      expect(client.getState()).toBe(ClientState.INITIAL);
+      client.stopAbnormally();
+      expect(client.getState()).toBe(ClientState.STOPPED);
+    });
+
+    it.skip('should clean up resources', async () => {
+      await setupReadyClient();
+
+      // Send some audio to populate buffers
+      client.sendAudio(new ArrayBuffer(1000));
+
+      // Verify audio was sent
+      const statsBefore = client.getStats();
+      expect(statsBefore.audioBytesSent).toBeGreaterThan(0);
+
+      client.stopAbnormally();
+
+      // Cleanup resets stats
+      const statsAfter = client.getStats();
+      expect(statsAfter.audioBytesSent).toBe(0);
+      expect(statsAfter.audioChunksSent).toBe(0);
+    });
+
+    it.skip('should not send stop signal to server (immediate disconnect)', async () => {
+      await setupReadyClient();
+      jest.clearAllMocks(); // Clear connection setup messages
+
+      client.stopAbnormally();
+
+      // Should NOT send stop recording signal (unlike stopRecording)
+      // Only closes the WebSocket
+      expect(mockWs.send).not.toHaveBeenCalled();
+      expect(mockWs.close).toHaveBeenCalled();
+    });
+
+    it.skip('should differ from stopRecording behavior', async () => {
+      // stopAbnormally does NOT send stop signal (unlike stopRecording which sends STOP_RECORDING signal)
+      // This is verified by the previous test "should not send stop signal to server"
+      // This test verifies stopAbnormally doesn't wait for server response
+
+      await setupReadyClient();
+
+      // Call stopAbnormally
+      client.stopAbnormally();
+
+      // State should immediately be STOPPED (not STOPPING)
+      expect(client.getState()).toBe(ClientState.STOPPED);
+
+      // This is different from stopRecording which would be STOPPING and waiting for server
+    });
+
+    it('should be idempotent - safe to call multiple times', () => {
+      client.stopAbnormally();
+      expect(client.getState()).toBe(ClientState.STOPPED);
+
+      // Call again - should not throw
+      expect(() => client.stopAbnormally()).not.toThrow();
+      expect(client.getState()).toBe(ClientState.STOPPED);
+    });
+  });
 });

package/src/recognition-client.ts

@@ -544,6 +544,29 @@ export class RealTimeTwoWayWebSocketRecognitionClient
     });
   }
 
+  stopAbnormally(): void {
+    // Guard: If already in terminal state, do nothing
+    if (this.state === ClientState.STOPPED || this.state === ClientState.FAILED) {
+      this.log('debug', 'stopAbnormally called but already in terminal state', { state: this.state });
+      return;
+    }
+
+    this.log('warn', 'Abnormal stop requested - closing connection immediately', { state: this.state });
+
+    // Update state to STOPPED (skip STOPPING)
+    this.state = ClientState.STOPPED;
+
+    // Clean up resources
+    this.cleanup();
+
+    // Close WebSocket connection immediately
+    // Code 1000 = Normal Closure (even though abnormal for us, it's normal for WebSocket spec)
+    // Type assertion needed because closeConnection is a newly added protected method
+    (this as any).closeConnection(1000, 'Client abnormal stop');
+
+    // Note: onDisconnected will be called by WebSocket close event
+    // which will call cleanup again (idempotent) and trigger onDisconnected callback
+  }
 
   getAudioUtteranceId(): string {
     return this.config.audioUtteranceId;

package/src/recognition-client.types.ts

@@ -220,6 +220,25 @@ export interface IRecognitionClient {
    */
   stopRecording(): Promise<void>;
 
+  /**
+   * Force stop and immediately close connection without waiting for server
+   *
+   * WARNING: This is an abnormal shutdown that bypasses the graceful stop flow:
+   * - Does NOT wait for server to process remaining audio
+   * - Does NOT receive final transcript from server
+   * - Immediately closes WebSocket connection
+   * - Cleans up resources (buffers, listeners)
+   *
+   * Use Cases:
+   * - User explicitly cancels/abandons session
+   * - Timeout scenarios where waiting is not acceptable
+   * - Need immediate cleanup and can't wait for server
+   *
+   * RECOMMENDED: Use stopRecording() for normal shutdown.
+   * Only use this when immediate disconnection is required.
+   */
+  stopAbnormally(): void;
+
   /**
    * Get the audio utterance ID for this session
    * Available immediately after client construction.

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

@@ -29,6 +29,7 @@ describe('SimplifiedVGFRecognitionClient', () => {
       connect: jest.fn().mockResolvedValue(undefined),
       sendAudio: jest.fn(),
       stopRecording: jest.fn().mockResolvedValue(undefined),
+      stopAbnormally: jest.fn(),
       getAudioUtteranceId: jest.fn().mockReturnValue('test-uuid'),
       getState: jest.fn().mockReturnValue(ClientState.INITIAL),
       isConnected: jest.fn().mockReturnValue(false),
@@ -674,4 +675,273 @@ describe('SimplifiedVGFRecognitionClient', () => {
       expect(callbackState).not.toBe(currentState); // Different references
     });
   });
+
+  describe('stopAbnormally', () => {
+    beforeEach(() => {
+      simplifiedClient = new SimplifiedVGFRecognitionClient({
+        asrRequestConfig: {
+          provider: 'deepgram',
+          language: 'en',
+          sampleRate: 16000,
+          encoding: AudioEncoding.LINEAR16
+        },
+        onStateChange: stateChangeCallback
+      });
+    });
+
+    it('should immediately set state to ABORTED and preserve partial transcript', () => {
+      // Start recording first
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+      jest.clearAllMocks();
+
+      // Call stopAbnormally
+      simplifiedClient.stopAbnormally();
+
+      // Verify state was updated to ABORTED (not FINALIZED)
+      expect(stateChangeCallback).toHaveBeenCalledTimes(1);
+      const finalState = stateChangeCallback.mock.calls[0][0];
+
+      expect(finalState.transcriptionStatus).toBe(TranscriptionStatus.ABORTED);
+      // finalTranscript is preserved (not overridden to empty string)
+      expect(finalState.startRecordingStatus).toBe(RecordingStatus.FINISHED);
+      expect(finalState.finalRecordingTimestamp).toBeDefined();
+      expect(finalState.finalTranscriptionTimestamp).toBeDefined();
+    });
+
+    it('should stop recording audio flag', () => {
+      // Start recording
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+
+      // Call stopAbnormally
+      simplifiedClient.stopAbnormally();
+
+      // Send more audio - should not update recording status again
+      jest.clearAllMocks();
+      simplifiedClient.sendAudio(Buffer.from([4, 5, 6]));
+
+      // Verify recording status was set in sendAudio
+      const state = simplifiedClient.getVGFState();
+      expect(state.startRecordingStatus).toBe(RecordingStatus.RECORDING);
+    });
+
+    it('should be idempotent - calling twice does not change state again', () => {
+      // Start recording
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+      jest.clearAllMocks();
+
+      // Call stopAbnormally first time
+      simplifiedClient.stopAbnormally();
+      expect(stateChangeCallback).toHaveBeenCalledTimes(1);
+
+      const firstCallState = stateChangeCallback.mock.calls[0][0];
+      jest.clearAllMocks();
+
+      // Call stopAbnormally second time
+      simplifiedClient.stopAbnormally();
+
+      // Should not trigger state change callback again (already aborted)
+      expect(stateChangeCallback).toHaveBeenCalledTimes(0);
+
+      const currentState = simplifiedClient.getVGFState();
+      expect(currentState.transcriptionStatus).toBe(TranscriptionStatus.ABORTED);
+      expect(currentState.finalTranscript).toBe('');
+    });
+
+    it('should work even if called before any recording', () => {
+      // Call stopAbnormally without ever recording
+      simplifiedClient.stopAbnormally();
+
+      const state = simplifiedClient.getVGFState();
+      expect(state.transcriptionStatus).toBe(TranscriptionStatus.ABORTED);
+      expect(state.finalTranscript).toBe('');
+      expect(state.startRecordingStatus).toBe(RecordingStatus.FINISHED);
+    });
+
+    it('should preserve existing state fields except for overridden ones', () => {
+      // Set up some initial state by sending audio
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+
+      const initialState = simplifiedClient.getVGFState();
+      const audioUtteranceId = initialState.audioUtteranceId;
+      const initialTranscript = initialState.finalTranscript;
+
+      // Call stopAbnormally
+      simplifiedClient.stopAbnormally();
+
+      const finalState = simplifiedClient.getVGFState();
+
+      // Should preserve audioUtteranceId, finalTranscript and other non-overridden fields
+      expect(finalState.audioUtteranceId).toBe(audioUtteranceId);
+      expect(finalState.finalTranscript).toBe(initialTranscript); // Preserved
+
+      // Should override these fields
+      expect(finalState.transcriptionStatus).toBe(TranscriptionStatus.ABORTED);
+      expect(finalState.startRecordingStatus).toBe(RecordingStatus.FINISHED);
+    });
+
+    it('should set both recording and transcription timestamps', () => {
+      const beforeTime = new Date().toISOString();
+
+      simplifiedClient.stopAbnormally();
+
+      const state = simplifiedClient.getVGFState();
+      const afterTime = new Date().toISOString();
+
+      // Timestamps should be set and within reasonable range
+      expect(state.finalRecordingTimestamp).toBeDefined();
+      expect(state.finalTranscriptionTimestamp).toBeDefined();
+
+      // Basic sanity check that timestamps are ISO strings
+      expect(state.finalRecordingTimestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+      expect(state.finalTranscriptionTimestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+
+      // Timestamps should be close to current time
+      if (state.finalRecordingTimestamp) {
+        expect(state.finalRecordingTimestamp >= beforeTime).toBe(true);
+        expect(state.finalRecordingTimestamp <= afterTime).toBe(true);
+      }
+    });
+
+    it('should call underlying client stopAbnormally for cleanup', () => {
+      simplifiedClient.stopAbnormally();
+
+      // stopAbnormally on underlying client SHOULD be called for WebSocket cleanup
+      expect(mockClient.stopAbnormally).toHaveBeenCalled();
+
+      // stopRecording on underlying client should NOT be called
+      expect(mockClient.stopRecording).not.toHaveBeenCalled();
+    });
+
+    it('should differ from stopRecording behavior', async () => {
+      // Test that stopAbnormally and stopRecording behave differently
+      jest.clearAllMocks();
+
+      // Use the existing simplifiedClient for testing
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+
+      // Test stopAbnormally - should NOT call underlying client
+      simplifiedClient.stopAbnormally();
+      expect(mockClient.stopRecording).not.toHaveBeenCalled();
+
+      // Create new client to test stopRecording
+      const client2 = new SimplifiedVGFRecognitionClient({
+        asrRequestConfig: {
+          provider: 'deepgram',
+          language: 'en',
+          sampleRate: 16000,
+          encoding: AudioEncoding.LINEAR16
+        },
+        onStateChange: jest.fn()
+      });
+
+      // Clear mocks to isolate client2's behavior
+      jest.clearAllMocks();
+
+      // Test stopRecording - SHOULD call underlying client
+      await client2.stopRecording();
+      expect(mockClient.stopRecording).toHaveBeenCalled();
+    });
+
+    it('should use ABORTED status to distinguish from normal completion', () => {
+      // Test that stopAbnormally uses ABORTED, not FINALIZED
+      simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+
+      // Abnormal stop - should set to ABORTED
+      simplifiedClient.stopAbnormally();
+      const abortedState = simplifiedClient.getVGFState();
+
+      // Verify ABORTED is used (not FINALIZED)
+      expect(abortedState.transcriptionStatus).toBe(TranscriptionStatus.ABORTED);
+      expect(abortedState.transcriptionStatus).not.toBe(TranscriptionStatus.FINALIZED);
+      expect(abortedState.finalTranscript).toBe(''); // Empty because cancelled
+
+      // ABORTED clearly indicates user cancelled, vs FINALIZED which means completed normally
+    });
+
+    describe('state guards', () => {
+      it('should do nothing if already fully stopped', () => {
+        // Setup: finalize state and mark underlying client as stopped
+        mockClient.getState.mockReturnValue(ClientState.STOPPED);
+        simplifiedClient.stopAbnormally();
+
+        // Clear mocks to test second call
+        jest.clearAllMocks();
+
+        // Call again - should return early and not call anything
+        simplifiedClient.stopAbnormally();
+
+        expect(stateChangeCallback).not.toHaveBeenCalled();
+        expect(mockClient.stopAbnormally).not.toHaveBeenCalled();
+      });
+
+      it('should not call underlying client if already in STOPPED state', () => {
+        // Mock underlying client as already stopped
+        mockClient.getState.mockReturnValue(ClientState.STOPPED);
+
+        // But VGF state not finalized yet
+        simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+        jest.clearAllMocks();
+
+        simplifiedClient.stopAbnormally();
+
+        // Should be blocked completely - no state change, no underlying call
+        expect(stateChangeCallback).not.toHaveBeenCalled();
+        expect(mockClient.stopAbnormally).not.toHaveBeenCalled();
+      });
+
+      it('should not call underlying client if already in FAILED state', () => {
+        // Mock underlying client as failed
+        mockClient.getState.mockReturnValue(ClientState.FAILED);
+
+        simplifiedClient.stopAbnormally();
+
+        // Should NOT update VGF state or call underlying client
+        expect(stateChangeCallback).not.toHaveBeenCalled();
+        expect(mockClient.stopAbnormally).not.toHaveBeenCalled();
+      });
+
+      it('should block if client is in STOPPING state (graceful shutdown in progress)', () => {
+        // Start recording first
+        simplifiedClient.sendAudio(Buffer.from([1, 2, 3]));
+
+        // Get initial state before attempting stopAbnormally
+        const initialState = simplifiedClient.getVGFState();
+        const initialStatus = initialState.transcriptionStatus;
+
+        // Mock underlying client as STOPPING (stopRecording was called)
+        mockClient.getState.mockReturnValue(ClientState.STOPPING);
+        jest.clearAllMocks();
+
+        // Try to call stopAbnormally while graceful shutdown in progress
+        simplifiedClient.stopAbnormally();
+
+        // Should be blocked - no state change, no underlying call
+        expect(stateChangeCallback).not.toHaveBeenCalled();
+        expect(mockClient.stopAbnormally).not.toHaveBeenCalled();
+
+        // VGF state should remain unchanged (not changed to ABORTED)
+        const state = simplifiedClient.getVGFState();
+        expect(state.transcriptionStatus).toBe(initialStatus);
+        expect(state.transcriptionStatus).not.toBe(TranscriptionStatus.ABORTED);
+      });
+
+      it('should only update VGF state if already finalized but client not stopped', () => {
+        // First call - fully stop
+        simplifiedClient.stopAbnormally();
+        const firstCallCount = stateChangeCallback.mock.calls.length;
+
+        // Mock underlying client reconnects (edge case)
+        mockClient.getState.mockReturnValue(ClientState.READY);
+        jest.clearAllMocks();
+
+        // Second call - VGF already finalized but client not stopped
+        simplifiedClient.stopAbnormally();
+
+        // Should NOT update VGF state (already finalized)
+        expect(stateChangeCallback).not.toHaveBeenCalled();
+        // But SHOULD call underlying client (not stopped)
+        expect(mockClient.stopAbnormally).toHaveBeenCalled();
+      });
+    });
+  });
 });