@bytexbyte/nxtlinq-ai-agent-ui-react-native-development 0.2.0 → 0.3.0

package/dist/voice/useVoiceTranscriptMessages.d.ts

@@ -0,0 +1,16 @@
+import type { Message, VoiceDoneEvent, VoiceTranscriptEvent } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import type { InteractionMode } from '../context/AgentAssistantContext';
+type VoiceTranscriptAgentApi = {
+    getMessages: () => Message[];
+    setMessages: (messages: Message[]) => void;
+    syncVoiceTurnHistory: (options?: {
+        last?: number;
+    }) => Promise<void>;
+};
+export declare function useVoiceTranscriptMessages(api: VoiceTranscriptAgentApi, interactionMode: InteractionMode, voiceSessionId: string | null): {
+    handleTranscript: (event: VoiceTranscriptEvent) => void;
+    handleDone: (event: VoiceDoneEvent) => void;
+    clearVoiceStream: () => void;
+};
+export {};
+//# sourceMappingURL=useVoiceTranscriptMessages.d.ts.map

package/dist/voice/useVoiceTranscriptMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceTranscriptMessages.d.ts","sourceRoot":"","sources":["../../src/voice/useVoiceTranscriptMessages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,oBAAoB,EACrB,MAAM,8CAA8C,CAAC;AAGtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE,KAAK,uBAAuB,GAAG;IAC7B,WAAW,EAAE,MAAM,OAAO,EAAE,CAAC;IAC7B,WAAW,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAC3C,oBAAoB,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACtE,CAAC;AAWF,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,uBAAuB,EAC5B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,MAAM,GAAG,IAAI;8BA6FnB,oBAAoB;wBA+BpB,cAAc;;EAwBzB"}

package/dist/voice/useVoiceTranscriptMessages.js

@@ -0,0 +1,133 @@
+import { mergeStreamingTranscript } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import { useCallback, useRef } from 'react';
+const STREAM_PREFIX = 'voice-stream-';
+function voiceMeta(sessionId) {
+    return {
+        voiceRealtime: true,
+        voiceSessionId: sessionId ?? undefined,
+    };
+}
+export function useVoiceTranscriptMessages(api, interactionMode, voiceSessionId) {
+    const streamIdRef = useRef(null);
+    const sessionIdRef = useRef(voiceSessionId);
+    sessionIdRef.current = voiceSessionId;
+    const isVoiceUiActive = useCallback(() => interactionMode === 'voice' && sessionIdRef.current != null, [interactionMode]);
+    const upsertStreaming = useCallback((text) => {
+        const messages = api.getMessages();
+        let streamId = streamIdRef.current;
+        if (!streamId) {
+            streamId = `${STREAM_PREFIX}${Date.now()}`;
+            streamIdRef.current = streamId;
+        }
+        const idx = messages.findIndex((m) => m.id === streamId);
+        const partialContent = idx >= 0
+            ? mergeStreamingTranscript(messages[idx]?.partialContent ?? '', text)
+            : text;
+        const meta = voiceMeta(sessionIdRef.current);
+        if (idx >= 0) {
+            api.setMessages(messages.map((m, i) => i === idx
+                ? { ...m, partialContent, isStreaming: true, metadata: { ...m.metadata, ...meta } }
+                : m));
+            return;
+        }
+        api.setMessages([
+            ...messages,
+            {
+                id: streamId,
+                role: 'assistant',
+                content: '',
+                partialContent,
+                isStreaming: true,
+                timestamp: new Date().toISOString(),
+                metadata: meta,
+            },
+        ]);
+    }, [api]);
+    const finalizeAssistant = useCallback((text, messageId) => {
+        const trimmed = text.trim();
+        streamIdRef.current = null;
+        if (!trimmed)
+            return;
+        const messages = api.getMessages();
+        const streamIdx = messages.findIndex((m) => m.isStreaming && m.role === 'assistant');
+        if (streamIdx >= 0) {
+            api.setMessages(messages.map((m, i) => i === streamIdx
+                ? {
+                    ...m,
+                    id: messageId ?? m.id,
+                    content: trimmed,
+                    partialContent: undefined,
+                    isStreaming: false,
+                    metadata: { ...m.metadata, ...voiceMeta(sessionIdRef.current) },
+                }
+                : m));
+            return;
+        }
+        const last = messages[messages.length - 1];
+        if (last?.role === 'assistant' && last.content === trimmed)
+            return;
+        api.setMessages([
+            ...messages,
+            {
+                id: messageId ?? `voice-asst-${Date.now()}`,
+                role: 'assistant',
+                content: trimmed,
+                timestamp: new Date().toISOString(),
+                metadata: voiceMeta(sessionIdRef.current),
+            },
+        ]);
+    }, [api]);
+    const handleTranscript = useCallback((event) => {
+        if (!isVoiceUiActive())
+            return;
+        const text = event.text?.trim() ?? '';
+        if (event.role === 'assistant') {
+            if (event.interim) {
+                if (text)
+                    upsertStreaming(text);
+                return;
+            }
+            if (text)
+                finalizeAssistant(text);
+            return;
+        }
+        if (event.role === 'user' && !event.interim && text) {
+            const messages = api.getMessages();
+            const last = messages[messages.length - 1];
+            if (last?.role === 'user' && last.content === text)
+                return;
+            api.setMessages([
+                ...messages,
+                {
+                    id: `voice-user-${Date.now()}`,
+                    role: 'user',
+                    content: text,
+                    timestamp: new Date().toISOString(),
+                    metadata: voiceMeta(sessionIdRef.current),
+                },
+            ]);
+        }
+    }, [api, finalizeAssistant, isVoiceUiActive, upsertStreaming]);
+    const handleDone = useCallback((event) => {
+        if (!isVoiceUiActive())
+            return;
+        if (event.guardrailsBlocked || event.billingBlocked || event.error) {
+            streamIdRef.current = null;
+            return;
+        }
+        const reply = event.replyText?.trim() ?? '';
+        if (reply) {
+            finalizeAssistant(reply, event.assistantMessageId ?? undefined);
+        }
+        else {
+            streamIdRef.current = null;
+        }
+        void api.syncVoiceTurnHistory({ last: 20 }).catch((err) => {
+            console.warn('[nxtlinq] syncVoiceTurnHistory after voice turn failed', err);
+        });
+    }, [api, finalizeAssistant, isVoiceUiActive]);
+    const clearVoiceStream = useCallback(() => {
+        streamIdRef.current = null;
+    }, []);
+    return { handleTranscript, handleDone, clearVoiceStream };
+}

package/dist/voice/useWsRealtimeAudio.d.ts

@@ -0,0 +1,17 @@
+import type { VoiceSession, VoiceStatus } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import type { UseNxtlinqVoiceOptions } from '@bytexbyte/nxtlinq-ai-agent-react-native-development';
+type WsVoiceCallbacks = Pick<UseNxtlinqVoiceOptions, 'onOpen' | 'onAudioDelta' | 'onClose' | 'onError'>;
+export type UseWsRealtimeAudioOptions = {
+    voiceStatus: VoiceStatus;
+    muteAfterSilenceCommit: () => void;
+};
+export declare function useWsRealtimeAudio(isCaptureActive: boolean, isVoiceActive: boolean, options: UseWsRealtimeAudioOptions): {
+    buildCallbacks: (overrides?: Partial<WsVoiceCallbacks>) => WsVoiceCallbacks;
+    bindSession: (session: VoiceSession | null, captureWhenUnmuted?: boolean) => void;
+    cleanup: () => void;
+    beginCapture: () => Promise<void>;
+    endCapture: (commit: boolean) => void;
+    getOutputAudioLevel: () => number;
+};
+export {};
+//# sourceMappingURL=useWsRealtimeAudio.d.ts.map

package/dist/voice/useWsRealtimeAudio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWsRealtimeAudio.d.ts","sourceRoot":"","sources":["../../src/voice/useWsRealtimeAudio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,8CAA8C,CAAC;AAC9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAOnG,KAAK,gBAAgB,GAAG,IAAI,CAC1B,sBAAsB,EACtB,QAAQ,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAClD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,WAAW,EAAE,WAAW,CAAC;IACzB,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACpC,CAAC;AAYF,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,OAAO,EACxB,aAAa,EAAE,OAAO,EACtB,OAAO,EAAE,yBAAyB;iCAsGnB,OAAO,CAAC,gBAAgB,CAAC,KAAG,gBAAgB;2BAX/C,YAAY,GAAG,IAAI;;;yBA7DU,OAAO;;EA0IjD"}

package/dist/voice/useWsRealtimeAudio.js

@@ -0,0 +1,165 @@
+import { waitForIOSAudioSessionReady } from '@bytexbyte/nxtlinq-ai-agent-react-native-development';
+import { useCallback, useEffect, useRef } from 'react';
+import { useVoiceSilenceCommit } from './useVoiceSilenceCommit';
+import { WsPcmPlayer } from './wsPcmPlayer';
+import { WsPcmRecorder } from './wsPcmRecorder';
+function isIOS() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Platform } = require('react-native');
+        return Platform.OS === 'ios';
+    }
+    catch {
+        return false;
+    }
+}
+export function useWsRealtimeAudio(isCaptureActive, isVoiceActive, options) {
+    const playerRef = useRef(null);
+    const recorderRef = useRef(null);
+    const sessionRef = useRef(null);
+    const isCaptureActiveRef = useRef(isCaptureActive);
+    isCaptureActiveRef.current = isCaptureActive;
+    const prevCaptureActiveRef = useRef(isCaptureActive);
+    const iosSessionPrimedRef = useRef(false);
+    const getSession = useCallback(() => sessionRef.current, []);
+    const muteAfterSilenceCommitRef = useRef(options.muteAfterSilenceCommit);
+    muteAfterSilenceCommitRef.current = options.muteAfterSilenceCommit;
+    const silence = useVoiceSilenceCommit(getSession, () => muteAfterSilenceCommitRef.current(), options.voiceStatus);
+    const silenceRef = useRef(silence);
+    silenceRef.current = silence;
+    const ensurePlayer = useCallback(async () => {
+        if (!playerRef.current) {
+            playerRef.current = new WsPcmPlayer();
+            playerRef.current.prewarm();
+        }
+        await playerRef.current.ensureRunning();
+    }, []);
+    const stopCapture = useCallback((commit) => {
+        const s = silenceRef.current;
+        s.clearPoll();
+        recorderRef.current?.stop();
+        if (!commit)
+            return;
+        if (s.consumeSkipCommitOnMute())
+            return;
+        s.tryCommit('manual');
+    }, []);
+    const startCapture = useCallback(async () => {
+        const session = sessionRef.current;
+        if (!session) {
+            console.warn('[nxtlinq] startCapture skipped: voice session not bound');
+            return;
+        }
+        if (isIOS() && !iosSessionPrimedRef.current) {
+            try {
+                await waitForIOSAudioSessionReady();
+                iosSessionPrimedRef.current = true;
+            }
+            catch (err) {
+                console.warn('[nxtlinq] waitForIOSAudioSessionReady failed', err);
+            }
+        }
+        const s = silenceRef.current;
+        if (!recorderRef.current) {
+            recorderRef.current = new WsPcmRecorder();
+        }
+        playerRef.current?.clearQueue();
+        recorderRef.current.bindSession(session);
+        recorderRef.current.setOnRms(s.onSpeechRms);
+        s.resetTurn();
+        try {
+            await recorderRef.current.initialize();
+            await recorderRef.current.start();
+            s.startPoll();
+        }
+        catch (err) {
+            s.clearPoll();
+            console.error('[nxtlinq] mic capture start failed', err);
+        }
+    }, []);
+    const cleanup = useCallback(() => {
+        const s = silenceRef.current;
+        s.clearPoll();
+        iosSessionPrimedRef.current = false;
+        recorderRef.current?.stop();
+        recorderRef.current?.cleanup();
+        recorderRef.current = null;
+        playerRef.current?.cleanup();
+        playerRef.current = null;
+        sessionRef.current = null;
+    }, []);
+    const stopCaptureRef = useRef(stopCapture);
+    const startCaptureRef = useRef(startCapture);
+    const cleanupRef = useRef(cleanup);
+    stopCaptureRef.current = stopCapture;
+    startCaptureRef.current = startCapture;
+    cleanupRef.current = cleanup;
+    const bindSession = useCallback((session, captureWhenUnmuted = false) => {
+        sessionRef.current = session;
+        recorderRef.current?.bindSession(session);
+        if (session && captureWhenUnmuted && isCaptureActiveRef.current) {
+            void startCaptureRef.current();
+        }
+    }, []);
+    const buildCallbacks = useCallback((overrides) => ({
+        onOpen: () => {
+            void ensurePlayer();
+            overrides?.onOpen?.();
+        },
+        onAudioDelta: (pcm16) => {
+            void ensurePlayer().then(() => playerRef.current?.addAudio(pcm16));
+            overrides?.onAudioDelta?.(pcm16);
+        },
+        onClose: (reason) => {
+            cleanupRef.current();
+            overrides?.onClose?.(reason);
+        },
+        onError: (err) => {
+            cleanupRef.current();
+            overrides?.onError?.(err);
+        },
+    }), [ensurePlayer]);
+    useEffect(() => {
+        if (!isVoiceActive) {
+            prevCaptureActiveRef.current = false;
+            cleanupRef.current();
+            return;
+        }
+        const prev = prevCaptureActiveRef.current;
+        prevCaptureActiveRef.current = isCaptureActive;
+        if (isCaptureActive && !prev) {
+            void startCaptureRef.current().catch((err) => {
+                console.error('[nxtlinq] mic capture start failed', err);
+            });
+            return;
+        }
+        if (!isCaptureActive && prev) {
+            stopCaptureRef.current(true);
+        }
+    }, [isCaptureActive, isVoiceActive]);
+    useEffect(() => {
+        if (!isVoiceActive)
+            return;
+        if (!recorderRef.current) {
+            recorderRef.current = new WsPcmRecorder();
+        }
+        void recorderRef.current.initialize().catch((err) => {
+            console.warn('[nxtlinq] WsPcmRecorder prewarm failed', err);
+        });
+    }, [isVoiceActive]);
+    useEffect(() => () => cleanupRef.current(), []);
+    const getOutputAudioLevel = useCallback(() => {
+        const fromPlayer = playerRef.current?.getAudioLevel() ?? 0;
+        if (fromPlayer > 0)
+            return fromPlayer;
+        return sessionRef.current?.getOutputAudioLevel() ?? 0;
+    }, []);
+    return {
+        buildCallbacks,
+        bindSession,
+        cleanup,
+        beginCapture: startCapture,
+        endCapture: stopCapture,
+        getOutputAudioLevel,
+    };
+}

package/dist/voice/voiceImagePickerOptions.d.ts

@@ -0,0 +1,11 @@
+/** Smaller payload for WS / SCTP voice channels (Berify-aligned). */
+export declare const VOICE_IMAGE_PICKER_OPTIONS: {
+    mediaType: "photo";
+    multiple: boolean;
+    compressImageMaxWidth: number;
+    compressImageMaxHeight: number;
+    compressImageQuality: number;
+    /** iOS albums are often HEIC; force JPEG for OpenAI-compatible MIME. */
+    forceJpg: boolean;
+};
+//# sourceMappingURL=voiceImagePickerOptions.d.ts.map

package/dist/voice/voiceImagePickerOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voiceImagePickerOptions.d.ts","sourceRoot":"","sources":["../../src/voice/voiceImagePickerOptions.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,eAAO,MAAM,0BAA0B;;;;;;IAMrC,wEAAwE;;CAEzE,CAAC"}

package/dist/voice/voiceImagePickerOptions.js

@@ -0,0 +1,10 @@
+/** Smaller payload for WS / SCTP voice channels (Berify-aligned). */
+export const VOICE_IMAGE_PICKER_OPTIONS = {
+    mediaType: 'photo',
+    multiple: false,
+    compressImageMaxWidth: 384,
+    compressImageMaxHeight: 384,
+    compressImageQuality: 0.55,
+    /** iOS albums are often HEIC; force JPEG for OpenAI-compatible MIME. */
+    forceJpg: true,
+};

package/dist/voice/voiceSilenceConstants.d.ts

@@ -0,0 +1,8 @@
+/** Min RMS to treat as user speech (~-42 dBFS). Berify-aligned. */
+export declare const MIC_SPEECH_RMS_THRESHOLD = 0.008;
+/** Louder threshold while assistant speaks — reduces echo false triggers. */
+export declare const MIC_BARGE_IN_RMS_THRESHOLD = 0.045;
+/** Commit turn after this much silence while mic is open. */
+export declare const MIC_SILENCE_COMMIT_MS = 400;
+export declare const MIC_SILENCE_POLL_MS = 100;
+//# sourceMappingURL=voiceSilenceConstants.d.ts.map

package/dist/voice/voiceSilenceConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voiceSilenceConstants.d.ts","sourceRoot":"","sources":["../../src/voice/voiceSilenceConstants.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAE9C,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,QAAQ,CAAC;AAEhD,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,eAAO,MAAM,mBAAmB,MAAM,CAAC"}

package/dist/voice/voiceSilenceConstants.js

@@ -0,0 +1,7 @@
+/** Min RMS to treat as user speech (~-42 dBFS). Berify-aligned. */
+export const MIC_SPEECH_RMS_THRESHOLD = 0.008;
+/** Louder threshold while assistant speaks — reduces echo false triggers. */
+export const MIC_BARGE_IN_RMS_THRESHOLD = 0.045;
+/** Commit turn after this much silence while mic is open. */
+export const MIC_SILENCE_COMMIT_MS = 400;
+export const MIC_SILENCE_POLL_MS = 100;

package/dist/voice/wsPcmPlayer.d.ts

@@ -0,0 +1,24 @@
+export declare class WsPcmPlayer {
+    private readonly sampleRate;
+    private readonly fadeSamples;
+    private audioContext;
+    private gainNode;
+    private analyserNode;
+    private analyserBuffer;
+    private readonly activeSources;
+    private queue;
+    private isPlaying;
+    private playHead;
+    private lastChunkRms;
+    private lastChunkAt;
+    ensureRunning(): Promise<void>;
+    prewarm(): void;
+    addAudio(pcm16: Int16Array | ArrayBuffer): void;
+    getAudioLevel(): number;
+    clearQueue(): void;
+    cleanup(): void;
+    private ensureContext;
+    /** Berify WavStreamPlayer: schedule chunks with lookahead + crossfade, no gaps. */
+    private pipelineQueue;
+}
+//# sourceMappingURL=wsPcmPlayer.d.ts.map

package/dist/voice/wsPcmPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsPcmPlayer.d.ts","sourceRoot":"","sources":["../../src/voice/wsPcmPlayer.ts"],"names":[],"mappings":"AAsBA,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2B;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmD;IAC/E,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoC;IAClE,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,WAAW,CAAK;IAElB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAQpC,OAAO,IAAI,IAAI;IAIf,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI;IAuB/C,aAAa,IAAI,MAAM;IAkBvB,UAAU,IAAI,IAAI;IAelB,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,aAAa;IAcrB,mFAAmF;IACnF,OAAO,CAAC,aAAa;CAqCtB"}

package/dist/voice/wsPcmPlayer.js

@@ -0,0 +1,146 @@
+import { AudioContext, } from 'react-native-audio-api';
+import { WS_REALTIME_SAMPLE_RATE } from './wsRealtimeConstants';
+const LEVEL_SCALE = 3.2;
+const LOOKAHEAD_SECONDS = 0.02;
+const CROSSFADE_SECONDS = 0.04;
+function applyFade(buffer, fadeSamples) {
+    const fade = Math.min(fadeSamples, Math.floor(buffer.length / 2));
+    if (fade <= 0)
+        return;
+    for (let i = 0; i < fade; i += 1) {
+        buffer[i] *= i / fade;
+        buffer[buffer.length - 1 - i] *= (fade - i) / fade;
+    }
+}
+export class WsPcmPlayer {
+    constructor() {
+        this.sampleRate = WS_REALTIME_SAMPLE_RATE;
+        this.fadeSamples = Math.max(1, Math.floor(this.sampleRate * 0.01));
+        this.audioContext = null;
+        this.gainNode = null;
+        this.analyserNode = null;
+        this.analyserBuffer = null;
+        this.activeSources = new Set();
+        this.queue = [];
+        this.isPlaying = true;
+        this.playHead = 0;
+        this.lastChunkRms = 0;
+        this.lastChunkAt = 0;
+    }
+    async ensureRunning() {
+        const ctx = this.ensureContext();
+        if (ctx.state === 'suspended') {
+            await ctx.resume();
+        }
+        this.isPlaying = true;
+    }
+    prewarm() {
+        this.ensureContext();
+    }
+    addAudio(pcm16) {
+        const ctx = this.ensureContext();
+        const int16 = pcm16 instanceof ArrayBuffer ? new Int16Array(pcm16) : pcm16;
+        if (int16.length === 0)
+            return;
+        const floats = new Float32Array(int16.length);
+        let sumSq = 0;
+        for (let i = 0; i < int16.length; i += 1) {
+            const sample = int16[i] / 32768;
+            floats[i] = Math.max(-1, Math.min(1, sample));
+            sumSq += sample * sample;
+        }
+        applyFade(floats, this.fadeSamples);
+        this.lastChunkRms = Math.min(1, Math.sqrt(sumSq / int16.length) * LEVEL_SCALE);
+        this.lastChunkAt = Date.now();
+        const buffer = ctx.createBuffer(1, floats.length, this.sampleRate);
+        buffer.getChannelData(0).set(floats);
+        this.queue.push(buffer);
+        this.isPlaying = true;
+        this.pipelineQueue();
+    }
+    getAudioLevel() {
+        const analyser = this.analyserNode;
+        const buf = this.analyserBuffer;
+        if (analyser && buf && this.activeSources.size > 0) {
+            analyser.getFloatTimeDomainData(buf);
+            let sumSq = 0;
+            for (let i = 0; i < buf.length; i += 1) {
+                const v = buf[i];
+                sumSq += v * v;
+            }
+            return Math.min(1, Math.sqrt(sumSq / buf.length) * LEVEL_SCALE);
+        }
+        if (Date.now() - this.lastChunkAt < 500) {
+            return this.lastChunkRms;
+        }
+        return 0;
+    }
+    clearQueue() {
+        for (const source of this.activeSources) {
+            try {
+                source.stop();
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        this.activeSources.clear();
+        this.queue = [];
+        this.playHead = this.audioContext?.currentTime ?? 0;
+        this.lastChunkRms = 0;
+        this.lastChunkAt = 0;
+    }
+    cleanup() {
+        this.clearQueue();
+        this.isPlaying = false;
+        this.analyserNode = null;
+        this.analyserBuffer = null;
+        this.gainNode = null;
+        this.audioContext = null;
+    }
+    ensureContext() {
+        if (!this.audioContext) {
+            this.audioContext = new AudioContext({ sampleRate: this.sampleRate });
+            this.gainNode = this.audioContext.createGain();
+            this.analyserNode = this.audioContext.createAnalyser();
+            this.analyserNode.fftSize = 512;
+            this.analyserBuffer = new Float32Array(this.analyserNode.fftSize);
+            this.gainNode.connect(this.analyserNode);
+            this.analyserNode.connect(this.audioContext.destination);
+            this.playHead = this.audioContext.currentTime;
+        }
+        return this.audioContext;
+    }
+    /** Berify WavStreamPlayer: schedule chunks with lookahead + crossfade, no gaps. */
+    pipelineQueue() {
+        const ctx = this.audioContext;
+        const gain = this.gainNode;
+        if (!ctx || !gain || !this.isPlaying)
+            return;
+        while (this.queue.length > 0) {
+            const audioBuffer = this.queue.shift();
+            if (!audioBuffer)
+                return;
+            const source = ctx.createBufferSource();
+            source.buffer = audioBuffer;
+            const perSourceGain = ctx.createGain();
+            source.connect(perSourceGain);
+            perSourceGain.connect(gain);
+            const now = ctx.currentTime;
+            const startAt = Math.max((this.playHead || now) - CROSSFADE_SECONDS * 0.75, now + LOOKAHEAD_SECONDS);
+            const duration = audioBuffer.duration;
+            const endAt = startAt + duration;
+            const fade = Math.min(CROSSFADE_SECONDS, duration / 2);
+            perSourceGain.gain.setValueAtTime(0, startAt);
+            perSourceGain.gain.linearRampToValueAtTime(1, startAt + fade);
+            perSourceGain.gain.setValueAtTime(1, endAt - fade);
+            perSourceGain.gain.linearRampToValueAtTime(0, endAt);
+            this.playHead = endAt;
+            this.activeSources.add(source);
+            source.start(startAt);
+            source.onEnded = () => {
+                this.activeSources.delete(source);
+            };
+        }
+    }
+}

package/dist/voice/wsPcmRecorder.d.ts

@@ -0,0 +1,26 @@
+import type { VoiceSession } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+/**
+ * Berify {@link WavRecorder}-aligned lifecycle: reuse one native AudioRecorder,
+ * configure playAndRecord on start, reset to playback on stop.
+ */
+export declare class WsPcmRecorder {
+    private recorder;
+    private recording;
+    private audioReadyAttached;
+    private session;
+    private onRms?;
+    initialize(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    bindSession(session: VoiceSession | null): void;
+    setOnRms(handler: (rms: number) => void): void;
+    private disposeRecorderInternal;
+    start(): Promise<void>;
+    stop(): void;
+    cleanup(): void;
+    get isRecording(): boolean;
+    private configureSession;
+    private resetSession;
+    private handleAudioReady;
+}
+//# sourceMappingURL=wsPcmRecorder.d.ts.map

package/dist/voice/wsPcmRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsPcmRecorder.d.ts","sourceRoot":"","sources":["../../src/voice/wsPcmRecorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC;AASjF;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,KAAK,CAAC,CAAwB;IAEhC,UAAU,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9D,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAI/C,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAI9C,OAAO,CAAC,uBAAuB;IAazB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC5B,IAAI,IAAI,IAAI;IAWZ,OAAO,IAAI,IAAI;IAmBf,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,gBAAgB;CAYzB"}