@volley/recognition-client-sdk-node22 0.1.424

package/dist/utils/message-handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Message Handler for Recognition Client
+ * Routes incoming WebSocket messages to appropriate callbacks
+ */
+import { type TranscriptionResultV1, type FunctionCallResultV1, type MetadataResultV1, type ErrorResultV1, type ClientControlMessageV1 } from '@recog/shared-types';
+export interface MessageHandlerCallbacks {
+    onTranscript: (result: TranscriptionResultV1) => void;
+    onFunctionCall: (result: FunctionCallResultV1) => void;
+    onMetadata: (metadata: MetadataResultV1) => void;
+    onError: (error: ErrorResultV1) => void;
+    onControlMessage: (msg: ClientControlMessageV1) => void;
+    logger?: (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: any) => void;
+}
+export declare class MessageHandler {
+    private firstTranscriptTime;
+    private sessionStartTime;
+    private callbacks;
+    constructor(callbacks: MessageHandlerCallbacks);
+    /**
+     * Set session start time for performance tracking
+     */
+    setSessionStartTime(time: number): void;
+    /**
+     * Handle incoming WebSocket message
+     */
+    handleMessage(msg: {
+        v: number;
+        type: string;
+        data: any;
+    }): void;
+    /**
+     * Handle transcript message and track performance metrics
+     * @param result - The transcription result from the server
+     */
+    private handleTranscription;
+    /**
+     * Get performance metrics
+     */
+    getMetrics(): {
+        sessionStartTime: number | null;
+        firstTranscriptTime: number | null;
+        timeToFirstTranscript: number | null;
+    };
+}
+//# sourceMappingURL=message-handler.d.ts.map

package/dist/utils/message-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-handler.d.ts","sourceRoot":"","sources":["../../src/utils/message-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACtD,cAAc,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACvD,UAAU,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACjD,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,gBAAgB,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAC5F;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,SAAS,CAA0B;gBAE/B,SAAS,EAAE,uBAAuB;IAI9C;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIvC;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI;IAsDhE;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;OAEG;IACH,UAAU;;;;;CAUX"}

package/dist/utils/url-builder.d.ts

@@ -0,0 +1,28 @@
+/**
+ * URL Builder for Recognition Client
+ * Handles WebSocket URL construction with query parameters
+ */
+import type { GameContextV1, Stage } from '@recog/shared-types';
+import type { RecognitionCallbackUrl } from '../recognition-client.types.js';
+export interface UrlBuilderConfig {
+    url?: string;
+    stage?: Stage | string;
+    audioUtteranceId: string;
+    callbackUrls?: RecognitionCallbackUrl[];
+    userId?: string;
+    gameSessionId?: string;
+    deviceId?: string;
+    accountId?: string;
+    questionAnswerId?: string;
+    platform?: string;
+    gameContext?: GameContextV1;
+    /** Standalone gameId - takes precedence over gameContext.gameId if both provided */
+    gameId?: string;
+}
+/**
+ * Build WebSocket URL with all query parameters
+ * Either `url` or `stage` must be provided (or defaults to production if neither provided)
+ * If both are provided, `url` takes precedence over `stage`
+ */
+export declare function buildWebSocketUrl(config: UrlBuilderConfig): string;
+//# sourceMappingURL=url-builder.d.ts.map

package/dist/utils/url-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-builder.d.ts","sourceRoot":"","sources":["../../src/utils/url-builder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CA6DlE"}

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

@@ -0,0 +1,66 @@
+/**
+ * VGF Recognition Mapper
+ *
+ * Maps between the existing recognition client types and the simplified VGF state.
+ * This provides a clean abstraction layer for game developers.
+ */
+import { RecognitionState } from './vgf-recognition-state.js';
+import { ClientState, IRecognitionClientConfig } from './recognition-client.types.js';
+import { TranscriptionResultV1, ErrorResultV1 } from '@recog/shared-types';
+/**
+ * Maps ClientState to RecordingStatus for VGF state
+ */
+export declare function mapClientStateToRecordingStatus(clientState: ClientState): string;
+/**
+ * Creates a VGF state from transcription result
+ */
+export declare function mapTranscriptionResultToState(currentState: RecognitionState, result: TranscriptionResultV1, isRecording: boolean): RecognitionState;
+/**
+ * Maps error to state
+ */
+export declare function mapErrorToState(currentState: RecognitionState, error: ErrorResultV1): RecognitionState;
+/**
+ * Creates initial VGF state from client config
+ */
+export declare function createVGFStateFromConfig(config: IRecognitionClientConfig): RecognitionState;
+/**
+ * Updates state when recording stops
+ */
+export declare function updateStateOnStop(currentState: RecognitionState): RecognitionState;
+/**
+ * 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 declare function resetRecognitionVGFState(currentState: RecognitionState): RecognitionState;
+/**
+ * Updates state when client becomes ready
+ */
+export declare function updateStateOnReady(currentState: RecognitionState): RecognitionState;
+/**
+ * Parses function call from transcript (STEP 3 support)
+ * This is a placeholder - actual implementation would use NLP/LLM
+ */
+export declare function extractFunctionCallFromTranscript(transcript: string, gameContext?: any): {
+    metadata?: string;
+    confidence?: number;
+} | null;
+/**
+ * Updates state with function call results (STEP 3)
+ */
+export declare function updateStateWithFunctionCall(currentState: RecognitionState, functionCall: {
+    metadata?: string;
+    confidence?: number;
+}): RecognitionState;
+//# sourceMappingURL=vgf-recognition-mapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgf-recognition-mapper.d.ts","sourceRoot":"","sources":["../src/vgf-recognition-mapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACH,gBAAgB,EAKnB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACH,WAAW,EACX,wBAAwB,EAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACH,qBAAqB,EACrB,aAAa,EAChB,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAmBhF;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CACzC,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,qBAAqB,EAC7B,WAAW,EAAE,OAAO,GACrB,gBAAgB,CAgDlB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC3B,YAAY,EAAE,gBAAgB,EAC9B,KAAK,EAAE,aAAa,GACrB,gBAAgB,CAOlB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,gBAAgB,CAU3F;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,gBAAgB,GAAG,gBAAgB,CAMlF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,gBAAgB,GAAG,gBAAgB,CASzF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,gBAAgB,GAAG,gBAAgB,CAKnF;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,CAC7C,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,GAAG,GAClB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiBnD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACvC,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,gBAAgB,CAOlB"}

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

@@ -0,0 +1,91 @@
+import { z } from "zod";
+/**
+ * VGF-style state schema for game-side recognition state/results management.
+ *
+ * This schema provides a standardized way for game developers to manage
+ * voice recognition state and results in their applications. It supports:
+ *
+ * STEP 1: Basic transcription flow
+ * STEP 2: Mic auto-stop upon correct answer (using partial transcripts)
+ * STEP 3: Semantic/function-call outcomes for game actions
+ *
+ * Ideally this should be part of a more centralized shared type library to free
+ * game developers and provide helper functions (VGF? Platform SDK?).
+ */
+export declare const RecognitionVGFStateSchema: z.ZodObject<{
+    audioUtteranceId: z.ZodString;
+    startRecordingStatus: z.ZodOptional<z.ZodString>;
+    transcriptionStatus: z.ZodOptional<z.ZodString>;
+    finalTranscript: z.ZodOptional<z.ZodString>;
+    finalConfidence: z.ZodOptional<z.ZodNumber>;
+    asrConfig: z.ZodOptional<z.ZodString>;
+    startRecordingTimestamp: z.ZodOptional<z.ZodString>;
+    finalRecordingTimestamp: z.ZodOptional<z.ZodString>;
+    finalTranscriptionTimestamp: z.ZodOptional<z.ZodString>;
+    pendingTranscript: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    pendingConfidence: z.ZodOptional<z.ZodNumber>;
+    functionCallMetadata: z.ZodOptional<z.ZodString>;
+    functionCallConfidence: z.ZodOptional<z.ZodNumber>;
+    finalFunctionCallTimestamp: z.ZodOptional<z.ZodString>;
+    promptSlotMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    recognitionActionProcessingState: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audioUtteranceId: string;
+    pendingTranscript: string;
+    startRecordingStatus?: string | undefined;
+    transcriptionStatus?: string | undefined;
+    finalTranscript?: string | undefined;
+    finalConfidence?: number | undefined;
+    asrConfig?: string | undefined;
+    startRecordingTimestamp?: string | undefined;
+    finalRecordingTimestamp?: string | undefined;
+    finalTranscriptionTimestamp?: string | undefined;
+    pendingConfidence?: number | undefined;
+    functionCallMetadata?: string | undefined;
+    functionCallConfidence?: number | undefined;
+    finalFunctionCallTimestamp?: string | undefined;
+    promptSlotMap?: Record<string, string[]> | undefined;
+    recognitionActionProcessingState?: string | undefined;
+}, {
+    audioUtteranceId: string;
+    startRecordingStatus?: string | undefined;
+    transcriptionStatus?: string | undefined;
+    finalTranscript?: string | undefined;
+    finalConfidence?: number | undefined;
+    asrConfig?: string | undefined;
+    startRecordingTimestamp?: string | undefined;
+    finalRecordingTimestamp?: string | undefined;
+    finalTranscriptionTimestamp?: string | undefined;
+    pendingTranscript?: string | undefined;
+    pendingConfidence?: number | undefined;
+    functionCallMetadata?: string | undefined;
+    functionCallConfidence?: number | undefined;
+    finalFunctionCallTimestamp?: string | undefined;
+    promptSlotMap?: Record<string, string[]> | undefined;
+    recognitionActionProcessingState?: string | undefined;
+}>;
+export type RecognitionState = z.infer<typeof RecognitionVGFStateSchema>;
+export declare const RecordingStatus: {
+    readonly NOT_READY: "NOT_READY";
+    readonly READY: "READY";
+    readonly RECORDING: "RECORDING";
+    readonly FINISHED: "FINISHED";
+};
+export type RecordingStatusType = typeof RecordingStatus[keyof typeof RecordingStatus];
+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];
+export declare const RecognitionActionProcessingState: {
+    readonly NOT_STARTED: "NOT_STARTED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly COMPLETED: "COMPLETED";
+};
+export type RecognitionActionProcessingStateType = typeof RecognitionActionProcessingState[keyof typeof RecognitionActionProcessingState];
+export declare function createInitialRecognitionState(audioUtteranceId: string): RecognitionState;
+export declare function isValidRecordingStatusTransition(from: string | undefined, to: string): boolean;
+//# sourceMappingURL=vgf-recognition-state.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BpC,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;AAElG,eAAO,MAAM,gCAAgC;;;;CAInC,CAAA;AAEV,MAAM,MAAM,oCAAoC,GAAG,OAAO,gCAAgC,CAAC,MAAM,OAAO,gCAAgC,CAAC,CAAA;AAGzI,wBAAgB,6BAA6B,CAAC,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAQxF;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAa9F"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@volley/recognition-client-sdk-node22",
+  "version": "0.1.424",
+  "description": "Recognition Service TypeScript/Node.js Client SDK (TypeScript 5.4.5 compatible build)",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.bundled.d.ts",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.bundled.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.bundled.d.ts",
+      "import": "./dist/recog-client-sdk.browser.js",
+      "default": "./dist/recog-client-sdk.browser.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "uuid": "^9.0.0",
+    "ws": "~8.18.0",
+    "zod": "3.22.4"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/github": "12.0.0",
+    "@semantic-release/npm": "13.1.1",
+    "@semantic-release/release-notes-generator": "14.1.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "~20.11.27",
+    "@types/uuid": "^9.0.2",
+    "@types/ws": "^8.5.5",
+    "esbuild": "0.23.0",
+    "jest": "^29.7.0",
+    "rollup": "^4.9.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "semantic-release": "^24.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "~5.4.5",
+    "@recog/shared-config": "1.0.0",
+    "@recog/websocket": "1.0.0",
+    "@recog/shared-types": "1.0.0",
+    "@recog/shared-utils": "1.0.0"
+  },
+  "keywords": [
+    "recognition",
+    "sdk",
+    "audio",
+    "speech"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "dev": "node build.mjs --watch",
+    "test": "jest --passWithNoTests",
+    "lint": "eslint src --ext .ts"
+  }
+}

package/src/browser.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser-only entry point for Recognition SDK
+ * Excludes server-side dependencies
+ * 
+ * Note: This file directly imports browser-compatible modules only,
+ * avoiding Node.js-specific code like the ws package.
+ */
+
+// Import directly from recognition-client
+// It uses WebSocketAudioClient which is browser-compatible
+export {
+  RealTimeTwoWayWebSocketRecognitionClient,
+  type RealTimeTwoWayWebSocketRecognitionClientConfig,
+  type TranscriptionResult
+} from './recognition-client.js';
+
+// Re-export the types needed for browser usage
+export {
+  AudioEncoding,
+  ControlSignalTypeV1 as ControlSignal,
+  type GameContextV1,
+  RecognitionContextTypeV1
+} from '@recog/shared-types';
+

package/src/config-builder.spec.ts

@@ -0,0 +1,265 @@
+/**
+ * Unit tests for ConfigBuilder
+ */
+
+import { ConfigBuilder } from './config-builder.js';
+import { RecognitionProvider, RecognitionContextTypeV1 } from '@recog/shared-types';
+
+describe('ConfigBuilder', () => {
+  it('should build empty config', () => {
+    const config = new ConfigBuilder().build();
+    expect(config).toBeDefined();
+  });
+
+  it('should set url', () => {
+    const config = new ConfigBuilder()
+      .url('ws://localhost:3101/ws/v1/recognize')
+      .build();
+    expect(config.url).toBe('ws://localhost:3101/ws/v1/recognize');
+  });
+
+  it('should set asrRequestConfig', () => {
+    const asrConfig = {
+      provider: RecognitionProvider.DEEPGRAM,
+      model: 'nova-2-general',
+      language: 'en-US',
+      sampleRate: 16000,
+      encoding: 'linear16'
+    };
+    const config = new ConfigBuilder()
+      .asrRequestConfig(asrConfig)
+      .build();
+    expect(config.asrRequestConfig).toEqual(asrConfig);
+  });
+
+  it('should set gameContext', () => {
+    const gameContext = {
+      type: RecognitionContextTypeV1.GAME_CONTEXT as const,
+      gameId: 'test-game',
+      gamePhase: 'test-phase'
+    };
+    const config = new ConfigBuilder()
+      .gameContext(gameContext)
+      .build();
+    expect(config.gameContext).toEqual(gameContext);
+  });
+
+  it('should set audioUtteranceId', () => {
+    const config = new ConfigBuilder()
+      .audioUtteranceId('test-utterance-id')
+      .build();
+    expect(config.audioUtteranceId).toBe('test-utterance-id');
+  });
+
+  it('should set callbackUrls', () => {
+    const callbackUrls = [
+      { url: 'https://example.com/callback', event: 'transcript' as const }
+    ];
+    const config = new ConfigBuilder()
+      .callbackUrls(callbackUrls)
+      .build();
+    expect(config.callbackUrls).toEqual(callbackUrls);
+  });
+
+  it('should set userId', () => {
+    const config = new ConfigBuilder()
+      .userId('user-123')
+      .build();
+    expect(config.userId).toBe('user-123');
+  });
+
+  it('should set gameSessionId', () => {
+    const config = new ConfigBuilder()
+      .gameSessionId('session-456')
+      .build();
+    expect(config.gameSessionId).toBe('session-456');
+  });
+
+  it('should set deviceId', () => {
+    const config = new ConfigBuilder()
+      .deviceId('device-789')
+      .build();
+    expect(config.deviceId).toBe('device-789');
+  });
+
+  it('should set accountId', () => {
+    const config = new ConfigBuilder()
+      .accountId('account-abc')
+      .build();
+    expect(config.accountId).toBe('account-abc');
+  });
+
+  it('should set questionAnswerId', () => {
+    const config = new ConfigBuilder()
+      .questionAnswerId('qa-xyz')
+      .build();
+    expect(config.questionAnswerId).toBe('qa-xyz');
+  });
+
+  it('should set platform', () => {
+    const config = new ConfigBuilder()
+      .platform('ios')
+      .build();
+    expect(config.platform).toBe('ios');
+  });
+
+  it('should set onTranscript callback', () => {
+    const callback = jest.fn();
+    const config = new ConfigBuilder()
+      .onTranscript(callback)
+      .build();
+    expect(config.onTranscript).toBe(callback);
+  });
+
+  it('should set onMetadata callback', () => {
+    const callback = jest.fn();
+    const config = new ConfigBuilder()
+      .onMetadata(callback)
+      .build();
+    expect(config.onMetadata).toBe(callback);
+  });
+
+  it('should set onError callback', () => {
+    const callback = jest.fn();
+    const config = new ConfigBuilder()
+      .onError(callback)
+      .build();
+    expect(config.onError).toBe(callback);
+  });
+
+  it('should set onConnected callback', () => {
+    const callback = jest.fn();
+    const config = new ConfigBuilder()
+      .onConnected(callback)
+      .build();
+    expect(config.onConnected).toBe(callback);
+  });
+
+  it('should set onDisconnected callback', () => {
+    const callback = jest.fn();
+    const config = new ConfigBuilder()
+      .onDisconnected(callback)
+      .build();
+    expect(config.onDisconnected).toBe(callback);
+  });
+
+  it('should set highWaterMark', () => {
+    const config = new ConfigBuilder()
+      .highWaterMark(1000)
+      .build();
+    expect(config.highWaterMark).toBe(1000);
+  });
+
+  it('should set lowWaterMark', () => {
+    const config = new ConfigBuilder()
+      .lowWaterMark(500)
+      .build();
+    expect(config.lowWaterMark).toBe(500);
+  });
+
+  it('should set maxBufferDurationSec', () => {
+    const config = new ConfigBuilder()
+      .maxBufferDurationSec(10)
+      .build();
+    expect(config.maxBufferDurationSec).toBe(10);
+  });
+
+  it('should set chunksPerSecond', () => {
+    const config = new ConfigBuilder()
+      .chunksPerSecond(50)
+      .build();
+    expect(config.chunksPerSecond).toBe(50);
+  });
+
+  it('should set logger', () => {
+    const logger = jest.fn();
+    const config = new ConfigBuilder()
+      .logger(logger)
+      .build();
+    expect(config.logger).toBe(logger);
+  });
+
+  it('should support method chaining', () => {
+    const config = new ConfigBuilder()
+      .url('ws://localhost:3101/ws/v1/recognize')
+      .audioUtteranceId('test-id')
+      .userId('user-123')
+      .gameSessionId('session-456')
+      .deviceId('device-789')
+      .platform('ios')
+      .highWaterMark(1000)
+      .lowWaterMark(500)
+      .build();
+
+    expect(config.url).toBe('ws://localhost:3101/ws/v1/recognize');
+    expect(config.audioUtteranceId).toBe('test-id');
+    expect(config.userId).toBe('user-123');
+    expect(config.gameSessionId).toBe('session-456');
+    expect(config.deviceId).toBe('device-789');
+    expect(config.platform).toBe('ios');
+    expect(config.highWaterMark).toBe(1000);
+    expect(config.lowWaterMark).toBe(500);
+  });
+
+  it('should build complete configuration', () => {
+    const onTranscript = jest.fn();
+    const onError = jest.fn();
+    const onConnected = jest.fn();
+    const onDisconnected = jest.fn();
+    const logger = jest.fn();
+
+    const config = new ConfigBuilder()
+      .url('ws://localhost:3101/ws/v1/recognize')
+      .asrRequestConfig({
+        provider: RecognitionProvider.DEEPGRAM,
+        model: 'nova-2-general',
+        language: 'en-US',
+        sampleRate: 16000,
+        encoding: 'linear16'
+      })
+      .gameContext({
+        type: RecognitionContextTypeV1.GAME_CONTEXT as const,
+        gameId: 'test-game',
+        gamePhase: 'test-phase'
+      })
+      .audioUtteranceId('test-utterance-id')
+      .userId('user-123')
+      .gameSessionId('session-456')
+      .deviceId('device-789')
+      .accountId('account-abc')
+      .questionAnswerId('qa-xyz')
+      .platform('ios')
+      .onTranscript(onTranscript)
+      .onError(onError)
+      .onConnected(onConnected)
+      .onDisconnected(onDisconnected)
+      .highWaterMark(1000)
+      .lowWaterMark(500)
+      .maxBufferDurationSec(10)
+      .chunksPerSecond(50)
+      .logger(logger)
+      .build();
+
+    expect(config).toMatchObject({
+      url: 'ws://localhost:3101/ws/v1/recognize',
+      audioUtteranceId: 'test-utterance-id',
+      userId: 'user-123',
+      gameSessionId: 'session-456',
+      deviceId: 'device-789',
+      accountId: 'account-abc',
+      questionAnswerId: 'qa-xyz',
+      platform: 'ios',
+      highWaterMark: 1000,
+      lowWaterMark: 500,
+      maxBufferDurationSec: 10,
+      chunksPerSecond: 50
+    });
+    expect(config.asrRequestConfig?.provider).toBe(RecognitionProvider.DEEPGRAM);
+    expect(config.gameContext?.gameId).toBe('test-game');
+    expect(config.onTranscript).toBe(onTranscript);
+    expect(config.onError).toBe(onError);
+    expect(config.onConnected).toBe(onConnected);
+    expect(config.onDisconnected).toBe(onDisconnected);
+    expect(config.logger).toBe(logger);
+  });
+});