@bytexbyte/nxtlinq-ai-agent-ui-react-development 0.1.1

package/dist/legacy/index.d.ts

@@ -0,0 +1,14 @@
+export { ChatBot } from './chatbot/ChatBot';
+export { ChatBotProvider, useChatBot } from './chatbot/context/ChatBotContext';
+export { ChatBotUI } from './chatbot/ui/ChatBotUI';
+export { MessageInput } from './chatbot/ui/MessageInput';
+export { MessageList } from './chatbot/ui/MessageList';
+export { ModelSelector } from './chatbot/ui/ModelSelector';
+export { NotificationModal } from './chatbot/ui/NotificationModal';
+export { PermissionForm } from './chatbot/ui/PermissionForm';
+export { PresetMessages } from './chatbot/ui/PresetMessages';
+export { BerifyMeModal } from './chatbot/ui/BerifyMeModal';
+export type { AIModel, AITMetadata, ChatBotContextType, ChatBotProps, NovaError, NovaResponse, PresetMessage, ToolCall, ToolUse, } from './chatbot/types/ChatBotTypes';
+/** Alias for consumers migrating to the new package naming. */
+export { ChatBot as NxtlinqChatBot } from './chatbot/ChatBot';
+//# sourceMappingURL=index.d.ts.map

package/dist/legacy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/legacy/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,YAAY,EACV,OAAO,EACP,WAAW,EACX,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,OAAO,GACR,MAAM,8BAA8B,CAAC;AAEtC,+DAA+D;AAC/D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/legacy/index.js

@@ -0,0 +1,12 @@
+export { ChatBot } from './chatbot/ChatBot';
+export { ChatBotProvider, useChatBot } from './chatbot/context/ChatBotContext';
+export { ChatBotUI } from './chatbot/ui/ChatBotUI';
+export { MessageInput } from './chatbot/ui/MessageInput';
+export { MessageList } from './chatbot/ui/MessageList';
+export { ModelSelector } from './chatbot/ui/ModelSelector';
+export { NotificationModal } from './chatbot/ui/NotificationModal';
+export { PermissionForm } from './chatbot/ui/PermissionForm';
+export { PresetMessages } from './chatbot/ui/PresetMessages';
+export { BerifyMeModal } from './chatbot/ui/BerifyMeModal';
+/** Alias for consumers migrating to the new package naming. */
+export { ChatBot as NxtlinqChatBot } from './chatbot/ChatBot';

package/dist/theme/defaultTheme.d.ts

@@ -0,0 +1,3 @@
+import type { AgentAssistantTheme } from '../types';
+export declare const defaultAgentAssistantTheme: AgentAssistantTheme;
+//# sourceMappingURL=defaultTheme.d.ts.map

package/dist/theme/defaultTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTheme.d.ts","sourceRoot":"","sources":["../../src/theme/defaultTheme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD,eAAO,MAAM,0BAA0B,EAAE,mBAmBxC,CAAC"}

package/dist/theme/defaultTheme.js

@@ -0,0 +1,20 @@
+export const defaultAgentAssistantTheme = {
+    colors: {
+        background: '#f8fafc',
+        surface: '#ffffff',
+        border: '#e2e8f0',
+        primary: '#2563eb',
+        primaryText: '#ffffff',
+        userBubble: '#2563eb',
+        userText: '#ffffff',
+        assistantBubble: '#f1f5f9',
+        assistantText: '#0f172a',
+        mutedText: '#64748b',
+        error: '#dc2626',
+        voiceActive: '#22c55e',
+        voiceSpeaking: '#ec4899',
+    },
+    spacing: { xs: 4, sm: 8, md: 16, lg: 24 },
+    radius: { bubble: 12, panel: 8, button: 8 },
+    typography: { titleSize: 17, bodySize: 15, captionSize: 13 },
+};

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+import type { Message, ToolUse as CoreToolUse } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import type { NxtlinqAgentProviderProps } from '@bytexbyte/nxtlinq-ai-agent-web-development';
+import type { CSSProperties } from 'react';
+export type PresetMessage = {
+    text: string;
+    autoSend?: boolean;
+};
+export type AgentAssistantTheme = {
+    colors: {
+        background: string;
+        surface: string;
+        border: string;
+        primary: string;
+        primaryText: string;
+        userBubble: string;
+        userText: string;
+        assistantBubble: string;
+        assistantText: string;
+        mutedText: string;
+        error: string;
+        voiceActive: string;
+        voiceSpeaking: string;
+    };
+    spacing: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    radius: {
+        bubble: number;
+        panel: number;
+        button: number;
+    };
+    typography: {
+        titleSize: number;
+        bodySize: number;
+        captionSize: number;
+    };
+};
+export type NxtlinqAgentChatProps = Omit<NxtlinqAgentProviderProps, 'children'> & {
+    children?: NxtlinqAgentProviderProps['children'];
+    title?: string;
+    placeholder?: string;
+    presetMessages?: PresetMessage[];
+    loadHistoryOnMount?: boolean;
+    historyLast?: number;
+    enableVoice?: boolean;
+    enableFileUpload?: boolean;
+    startInVoiceMode?: boolean;
+    startWithMicMuted?: boolean;
+    holdMicDuringAssistant?: boolean;
+    theme?: Partial<AgentAssistantTheme>;
+    style?: CSSProperties;
+    headerStyle?: CSSProperties;
+    onMessage?: NxtlinqAgentProviderProps['onMessage'];
+    onError?: NxtlinqAgentProviderProps['onError'];
+    onToolUse?: NxtlinqAgentProviderProps['onToolUse'];
+};
+export type ToolUse = CoreToolUse;
+export type { Message };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,8CAA8C,CAAC;AACpG,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;KACZ,CAAC;IACF,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,UAAU,EAAE;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,yBAAyB,EAAE,UAAU,CAAC,GAAG;IAChF,QAAQ,CAAC,EAAE,yBAAyB,CAAC,UAAU,CAAC,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;IACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,SAAS,CAAC,EAAE,yBAAyB,CAAC,WAAW,CAAC,CAAC;IACnD,OAAO,CAAC,EAAE,yBAAyB,CAAC,SAAS,CAAC,CAAC;IAC/C,SAAS,CAAC,EAAE,yBAAyB,CAAC,WAAW,CAAC,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC;AAClC,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/voice/useVoiceConnectOrchestration.d.ts

@@ -0,0 +1,21 @@
+import type { VoiceDoneEvent, VoiceTranscriptEvent } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import type { UseNxtlinqAgentResult, UseNxtlinqVoiceResult } from '@bytexbyte/nxtlinq-ai-agent-web-development';
+import type { InteractionMode } from '../context/AgentAssistantContext';
+type VoiceCallbacks = {
+    handleTranscript: (event: VoiceTranscriptEvent) => void;
+    handleDone: (event: VoiceDoneEvent) => void;
+    clearVoiceStream: () => void;
+    prepareForVoiceConnect: () => void;
+    resetMicState: () => void;
+    clearAssistantMicHold: () => void;
+    setInteractionMode: (mode: InteractionMode) => void;
+    setIsVoiceConnecting: (connecting: boolean) => void;
+};
+export declare function useVoiceConnectOrchestration(agent: UseNxtlinqAgentResult, voice: UseNxtlinqVoiceResult, interactionMode: InteractionMode, micStartsMuted: boolean, callbacks: VoiceCallbacks): {
+    wrappedStartVoice: (options?: Parameters<typeof voice.startVoice>[0]) => Promise<import("@bytexbyte/nxtlinq-ai-agent-core-development").VoiceSession>;
+    wrappedStopVoice: () => Promise<void>;
+    wrappedInterrupt: () => void;
+    isVoiceChannelReady: boolean;
+};
+export {};
+//# sourceMappingURL=useVoiceConnectOrchestration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceConnectOrchestration.d.ts","sourceRoot":"","sources":["../../src/voice/useVoiceConnectOrchestration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACzG,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,6CAA6C,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE,KAAK,cAAc,GAAG;IACpB,gBAAgB,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACxD,UAAU,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAC5C,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,kBAAkB,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;IACpD,oBAAoB,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,qBAAqB,EAC5B,KAAK,EAAE,qBAAqB,EAC5B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,OAAO,EACvB,SAAS,EAAE,cAAc;kCAKZ,UAAU,CAAC,OAAO,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;;;;EAuFpD"}

package/dist/voice/useVoiceConnectOrchestration.js

@@ -0,0 +1,86 @@
+import { useCallback, useRef } from 'react';
+export function useVoiceConnectOrchestration(agent, voice, interactionMode, micStartsMuted, callbacks) {
+    const voiceConnectChainRef = useRef(Promise.resolve());
+    const wrappedStartVoice = useCallback((options) => {
+        const connect = async () => {
+            if (voice.voiceSessionId != null) {
+                await voice.stopVoice('restart_voice');
+            }
+            callbacks.prepareForVoiceConnect();
+            callbacks.setInteractionMode('voice');
+            callbacks.setIsVoiceConnecting(true);
+            try {
+                const session = await voice.startVoice({
+                    startWithMicMuted: micStartsMuted,
+                    keepMicCaptureActive: true,
+                    ...options,
+                    onOpen: () => {
+                        if (!micStartsMuted) {
+                            voice.muteMic(false);
+                        }
+                        options?.onOpen?.();
+                    },
+                    onClose: (reason) => {
+                        callbacks.clearVoiceStream();
+                        callbacks.resetMicState();
+                        const userInitiated = reason === 'switch_to_text' ||
+                            reason === 'client_stop' ||
+                            reason === 'mode_text_cleanup';
+                        if (userInitiated) {
+                            callbacks.setInteractionMode('text');
+                        }
+                        else {
+                            console.warn('[nxtlinq] voice session closed:', reason);
+                        }
+                        options?.onClose?.(reason);
+                    },
+                    onError: (err) => {
+                        callbacks.clearVoiceStream();
+                        callbacks.resetMicState();
+                        console.warn('[nxtlinq] voice session error:', err.message);
+                        options?.onError?.(err);
+                    },
+                    onTranscript: (event) => {
+                        callbacks.handleTranscript(event);
+                        options?.onTranscript?.(event);
+                    },
+                    onDone: (event) => {
+                        callbacks.handleDone(event);
+                        options?.onDone?.(event);
+                    },
+                });
+                return session;
+            }
+            catch (err) {
+                callbacks.setInteractionMode('text');
+                callbacks.resetMicState();
+                throw err;
+            }
+            finally {
+                callbacks.setIsVoiceConnecting(false);
+            }
+        };
+        const next = voiceConnectChainRef.current.then(connect, connect);
+        voiceConnectChainRef.current = next.catch(() => undefined);
+        return next;
+    }, [voice, micStartsMuted, callbacks]);
+    const wrappedStopVoice = useCallback(async () => {
+        await voice.stopVoice('client_stop');
+        callbacks.resetMicState();
+        callbacks.setInteractionMode('text');
+    }, [voice, callbacks]);
+    const wrappedInterrupt = useCallback(() => {
+        voice.interrupt();
+        callbacks.clearAssistantMicHold();
+    }, [voice, callbacks]);
+    const isVoiceChannelReady = interactionMode === 'voice' &&
+        voice.voiceSessionId != null &&
+        (Boolean(agent.agent.getVoiceSession()?.isAppChannelOpen()) ||
+            voice.voiceStatus === 'listening');
+    return {
+        wrappedStartVoice,
+        wrappedStopVoice,
+        wrappedInterrupt,
+        isVoiceChannelReady,
+    };
+}

package/dist/voice/useVoiceMicState.d.ts

@@ -0,0 +1,15 @@
+import type { UseNxtlinqVoiceResult } from '@bytexbyte/nxtlinq-ai-agent-web-development';
+export type UseVoiceMicStateOptions = {
+    startWithMicMuted?: boolean;
+    holdMicDuringAssistant?: boolean;
+    onBargeIn?: () => void;
+};
+export declare function useVoiceMicState(voice: UseNxtlinqVoiceResult, isVoiceConnecting: boolean, options?: UseVoiceMicStateOptions): {
+    isMicMuted: boolean;
+    isMicHeldForAssistant: boolean;
+    toggleVoiceMicMute: () => void;
+    prepareForVoiceConnect: () => void;
+    resetMicState: () => void;
+    clearAssistantMicHold: () => void;
+};
+//# sourceMappingURL=useVoiceMicState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceMicState.d.ts","sourceRoot":"","sources":["../../src/voice/useVoiceMicState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AAIzF,MAAM,MAAM,uBAAuB,GAAG;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AAEF,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,qBAAqB,EAC5B,iBAAiB,EAAE,OAAO,EAC1B,OAAO,CAAC,EAAE,uBAAuB;;;;;;;EAsGlC"}

package/dist/voice/useVoiceMicState.js

@@ -0,0 +1,94 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { ASSISTANT_MIC_HOLD_STATUSES } from './voiceMicConstants';
+export function useVoiceMicState(voice, isVoiceConnecting, options) {
+    const connectMuted = options?.startWithMicMuted !== false;
+    const holdDuringAssistant = options?.holdMicDuringAssistant !== false;
+    const userMicMutedRef = useRef(connectMuted);
+    const assistantMicHoldRef = useRef(false);
+    const userMicOptInRef = useRef(!connectMuted);
+    const [isMicMuted, setIsMicMuted] = useState(connectMuted);
+    const applyMicState = useCallback(() => {
+        const shouldMute = userMicMutedRef.current || assistantMicHoldRef.current;
+        voice.muteMic(shouldMute);
+        setIsMicMuted(shouldMute);
+    }, [voice]);
+    const resetMicState = useCallback(() => {
+        userMicMutedRef.current = false;
+        assistantMicHoldRef.current = false;
+        userMicOptInRef.current = false;
+        setIsMicMuted(false);
+    }, []);
+    const prepareForVoiceConnect = useCallback(() => {
+        userMicMutedRef.current = connectMuted;
+        userMicOptInRef.current = !connectMuted;
+        assistantMicHoldRef.current = false;
+        setIsMicMuted(connectMuted);
+        voice.muteMic(connectMuted);
+    }, [voice, connectMuted]);
+    useEffect(() => {
+        if (!isVoiceConnecting)
+            return;
+        userMicMutedRef.current = connectMuted;
+        voice.muteMic(connectMuted);
+        setIsMicMuted(connectMuted);
+    }, [isVoiceConnecting, voice, connectMuted]);
+    const prevVoiceStatusRef = useRef(voice.voiceStatus);
+    useEffect(() => {
+        const status = voice.voiceStatus;
+        const prev = prevVoiceStatusRef.current;
+        prevVoiceStatusRef.current = status;
+        if (holdDuringAssistant && ASSISTANT_MIC_HOLD_STATUSES.has(status)) {
+            if (!userMicMutedRef.current && userMicOptInRef.current) {
+                assistantMicHoldRef.current = false;
+                applyMicState();
+                return;
+            }
+            assistantMicHoldRef.current = true;
+            applyMicState();
+            return;
+        }
+        if (status === 'listening' || status === 'idle') {
+            assistantMicHoldRef.current = false;
+            if (connectMuted
+                && status === 'listening'
+                && prev === 'speaking'
+                && !userMicOptInRef.current) {
+                userMicMutedRef.current = true;
+            }
+            applyMicState();
+        }
+    }, [voice.voiceStatus, applyMicState, holdDuringAssistant, connectMuted]);
+    const toggleVoiceMicMute = useCallback(() => {
+        if (!voice.isVoiceActive && !isVoiceConnecting)
+            return;
+        if (assistantMicHoldRef.current && userMicMutedRef.current) {
+            assistantMicHoldRef.current = false;
+            userMicMutedRef.current = false;
+            userMicOptInRef.current = true;
+            options?.onBargeIn?.();
+            applyMicState();
+            return;
+        }
+        if (assistantMicHoldRef.current) {
+            userMicMutedRef.current = true;
+            applyMicState();
+            return;
+        }
+        const nextMuted = !userMicMutedRef.current;
+        userMicMutedRef.current = nextMuted;
+        userMicOptInRef.current = !nextMuted;
+        applyMicState();
+    }, [voice.isVoiceActive, isVoiceConnecting, applyMicState, options]);
+    const clearAssistantMicHold = useCallback(() => {
+        assistantMicHoldRef.current = false;
+        applyMicState();
+    }, [applyMicState]);
+    return {
+        isMicMuted,
+        isMicHeldForAssistant: ASSISTANT_MIC_HOLD_STATUSES.has(voice.voiceStatus),
+        toggleVoiceMicMute,
+        prepareForVoiceConnect,
+        resetMicState,
+        clearAssistantMicHold,
+    };
+}

package/dist/voice/useVoiceSilenceCommit.d.ts

@@ -0,0 +1,10 @@
+import type { VoiceSession, VoiceStatus } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+export declare function useVoiceSilenceCommit(getSession: () => VoiceSession | null, onMutedAfterCommit: () => void, voiceStatus: VoiceStatus): {
+    startPoll: () => void;
+    clearPoll: () => void;
+    resetTurn: () => void;
+    onSpeechRms: (rms: number) => void;
+    tryCommit: (reason: "silence" | "manual") => void;
+    consumeSkipCommitOnMute: () => boolean;
+};
+//# sourceMappingURL=useVoiceSilenceCommit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceSilenceCommit.d.ts","sourceRoot":"","sources":["../../src/voice/useVoiceSilenceCommit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,8CAA8C,CAAC;AAU9F,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,YAAY,GAAG,IAAI,EACrC,kBAAkB,EAAE,MAAM,IAAI,EAC9B,WAAW,EAAE,WAAW;;;;uBAmDc,MAAM;wBAhCL,SAAS,GAAG,QAAQ;;EAiD5D"}

package/dist/voice/useVoiceSilenceCommit.js

@@ -0,0 +1,67 @@
+import { useCallback, useRef } from 'react';
+import { ASSISTANT_MIC_HOLD_STATUSES } from './voiceMicConstants';
+import { MIC_BARGE_IN_RMS_THRESHOLD, MIC_SILENCE_COMMIT_MS, MIC_SILENCE_POLL_MS, MIC_SPEECH_RMS_THRESHOLD, } from './ws/voiceSilenceConstants';
+export function useVoiceSilenceCommit(getSession, onMutedAfterCommit, voiceStatus) {
+    const lastSpeechAtRef = useRef(0);
+    const hadSpeechRef = useRef(false);
+    const commitInFlightRef = useRef(false);
+    const skipCommitOnMuteRef = useRef(false);
+    const pollRef = useRef(null);
+    const voiceStatusRef = useRef(voiceStatus);
+    voiceStatusRef.current = voiceStatus;
+    const onMutedAfterCommitRef = useRef(onMutedAfterCommit);
+    onMutedAfterCommitRef.current = onMutedAfterCommit;
+    const clearPoll = useCallback(() => {
+        if (pollRef.current) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+        }
+    }, []);
+    const tryCommit = useCallback((reason) => {
+        const session = getSession();
+        if (commitInFlightRef.current)
+            return;
+        if (!hadSpeechRef.current) {
+            session?.clearInputAudio?.();
+            return;
+        }
+        commitInFlightRef.current = true;
+        hadSpeechRef.current = false;
+        session?.commitInputAudio?.();
+        if (reason === 'silence') {
+            skipCommitOnMuteRef.current = true;
+            onMutedAfterCommitRef.current();
+        }
+        queueMicrotask(() => { commitInFlightRef.current = false; });
+    }, [getSession]);
+    const startPoll = useCallback(() => {
+        clearPoll();
+        pollRef.current = setInterval(() => {
+            if (commitInFlightRef.current || !hadSpeechRef.current)
+                return;
+            if (Date.now() - lastSpeechAtRef.current < MIC_SILENCE_COMMIT_MS)
+                return;
+            tryCommit('silence');
+        }, MIC_SILENCE_POLL_MS);
+    }, [clearPoll, tryCommit]);
+    const resetTurn = useCallback(() => {
+        hadSpeechRef.current = false;
+        lastSpeechAtRef.current = Date.now();
+        getSession()?.clearInputAudio?.();
+    }, [getSession]);
+    const onSpeechRms = useCallback((rms) => {
+        const threshold = ASSISTANT_MIC_HOLD_STATUSES.has(voiceStatusRef.current)
+            ? MIC_BARGE_IN_RMS_THRESHOLD
+            : MIC_SPEECH_RMS_THRESHOLD;
+        if (rms >= threshold) {
+            lastSpeechAtRef.current = Date.now();
+            hadSpeechRef.current = true;
+        }
+    }, []);
+    const consumeSkipCommitOnMute = useCallback(() => {
+        const skip = skipCommitOnMuteRef.current;
+        skipCommitOnMuteRef.current = false;
+        return skip;
+    }, []);
+    return { startPoll, clearPoll, resetTurn, onSpeechRms, tryCommit, consumeSkipCommitOnMute };
+}

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;wBA4BpB,cAAc;;EAwBzB"}

package/dist/voice/useVoiceTranscriptMessages.js

@@ -0,0 +1,129 @@
+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') {
+            // Keep one streaming bubble for the whole turn; finalize only in handleDone.
+            if (text)
+                upsertStreaming(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,18 @@
+import type { VoiceSession, VoiceStatus } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+type WsVoiceCallbacks = {
+    onOpen?: () => void;
+    onAudioDelta?: (pcm16: Int16Array | ArrayBuffer) => void;
+    onClose?: (reason: string) => void;
+    onError?: (err: Error) => void;
+};
+export type UseWsRealtimeAudioOptions = {
+    voiceStatus: VoiceStatus;
+    muteAfterSilenceCommit: () => void;
+};
+export declare function useWsRealtimeAudio(isCaptureActive: boolean, isVoiceActive: boolean, options: UseWsRealtimeAudioOptions): {
+    bindSession: (session: VoiceSession | null, captureWhenUnmuted?: boolean) => void;
+    buildCallbacks: (overrides?: Partial<WsVoiceCallbacks>) => WsVoiceCallbacks;
+    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;AAM9F,KAAK,gBAAgB,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,KAAK,IAAI,CAAC;IACzD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,WAAW,EAAE,WAAW,CAAC;IACzB,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACpC,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,OAAO,EACxB,aAAa,EAAE,OAAO,EACtB,OAAO,EAAE,yBAAyB;2BAiEQ,YAAY,GAAG,IAAI;iCAQb,OAAO,CAAC,gBAAgB,CAAC,KAAG,gBAAgB;;EAgC7F"}