@bytexbyte/nxtlinq-ai-agent-web-development 0.1.1

package/dist/legacy/core/lib/useLocalStorage.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, SetStateAction } from 'react';
+/**
+ * Custom hook for managing localStorage with React state and cross-tab synchronization
+ * Automatically syncs changes across browser tabs using StorageEvent
+ *
+ * @param key - The key to store the value under in localStorage
+ * @param defaultValue - The default value to use if no value is stored
+ * @returns [storedValue, setStoredValue, isInitialized]
+ */
+export default function useLocalStorage<T>(key: string, defaultValue: T): [T, Dispatch<SetStateAction<T>>, boolean];
+//# sourceMappingURL=useLocalStorage.d.ts.map

package/dist/legacy/core/lib/useLocalStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalStorage.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/lib/useLocalStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAA+B,MAAM,OAAO,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CA8ElH"}

package/dist/legacy/core/lib/useLocalStorage.js

@@ -0,0 +1,83 @@
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Custom hook for managing localStorage with React state and cross-tab synchronization
+ * Automatically syncs changes across browser tabs using StorageEvent
+ *
+ * @param key - The key to store the value under in localStorage
+ * @param defaultValue - The default value to use if no value is stored
+ * @returns [storedValue, setStoredValue, isInitialized]
+ */
+export default function useLocalStorage(key, defaultValue) {
+    const [storedValue, setStoredValue] = useState(defaultValue);
+    const [isInitialized, setIsInitialized] = useState(false);
+    // Ref to track if we're currently processing a storage event (to prevent loops)
+    // Note: StorageEvent only fires in OTHER tabs, not the current tab, so this ref
+    // is mainly used to prevent any edge cases
+    const isProcessingStorageEventRef = useRef(false);
+    // Initialize from localStorage
+    useEffect(() => {
+        try {
+            const storageValue = localStorage.getItem(key);
+            if (storageValue !== null) {
+                const parsed = JSON.parse(storageValue);
+                setStoredValue(parsed);
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading from localStorage key "${key}":`, error);
+        }
+        setIsInitialized(true);
+    }, [key]);
+    // Save to localStorage when value changes
+    useEffect(() => {
+        if (!isInitialized || isProcessingStorageEventRef.current)
+            return;
+        try {
+            const serialized = JSON.stringify(storedValue);
+            const currentValue = localStorage.getItem(key);
+            // Only write if the value actually changed (avoid unnecessary writes)
+            if (currentValue !== serialized) {
+                localStorage.setItem(key, serialized);
+            }
+        }
+        catch (error) {
+            console.warn(`Error writing to localStorage key "${key}":`, error);
+        }
+    }, [storedValue, isInitialized, key]);
+    // Listen for storage changes from other tabs (cross-tab synchronization)
+    useEffect(() => {
+        const handleStorageChange = (e) => {
+            // Only handle events for this key and ignore events from the current tab
+            if (e.key !== key || e.storageArea !== localStorage) {
+                return;
+            }
+            // StorageEvent only fires in OTHER tabs, not the tab that made the change
+            // So we can safely update the state here
+            try {
+                isProcessingStorageEventRef.current = true;
+                if (e.newValue !== null) {
+                    const newValue = JSON.parse(e.newValue);
+                    setStoredValue(newValue);
+                }
+                else {
+                    // If newValue is null, it means the item was removed
+                    setStoredValue(defaultValue);
+                }
+            }
+            catch (error) {
+                console.warn(`Error parsing storage event for key "${key}":`, error);
+            }
+            finally {
+                // Reset the flag after a brief delay to allow state updates to complete
+                setTimeout(() => {
+                    isProcessingStorageEventRef.current = false;
+                }, 0);
+            }
+        };
+        window.addEventListener('storage', handleStorageChange);
+        return () => {
+            window.removeEventListener('storage', handleStorageChange);
+        };
+    }, [key, defaultValue]);
+    return [storedValue, setStoredValue, isInitialized];
+}

package/dist/legacy/core/lib/useResizable.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from 'react';
+export type ResizeCorner = 'nw' | 'ne' | 'sw' | 'se';
+interface Position {
+    x: number;
+    y: number;
+}
+interface Dimensions {
+    width: number;
+    height: number;
+}
+export declare const useResizable: (currentPositionRef?: RefObject<Position>) => {
+    dimensions: Dimensions;
+    handleResizeStart: (corner: ResizeCorner) => (event: React.PointerEvent<HTMLDivElement>) => void;
+    positionAdjustment: Position | null;
+};
+export {};
+//# sourceMappingURL=useResizable.d.ts.map

package/dist/legacy/core/lib/useResizable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResizable.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/lib/useResizable.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,SAAS,EAAE,MAAM,OAAO,CAAC;AAqB5E,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,UAAU,QAAQ;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AASD,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,YAAY,GAAI,qBAAqB,SAAS,CAAC,QAAQ,CAAC;;gCA6ExD,YAAY,aAAa,KAAK,CAAC,YAAY,CAAC,cAAc,CAAC;;CA0IvE,CAAC"}

package/dist/legacy/core/lib/useResizable.js

@@ -0,0 +1,203 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import useLocalStorage from './useLocalStorage';
+// Resizable chat window defaults
+const DEFAULT_WIDTH = 500;
+const DEFAULT_HEIGHT = 600;
+const ASPECT_RATIO = DEFAULT_WIDTH / DEFAULT_HEIGHT;
+const MIN_WIDTH = 320;
+const MIN_HEIGHT = 380;
+const VIEWPORT_MARGIN = 40; // Keep space from viewport edges
+const MOBILE_BREAKPOINT = 768;
+const MOBILE_EDGE_MARGIN = 12;
+const isMobileViewport = () => typeof window !== 'undefined' && window.innerWidth <= MOBILE_BREAKPOINT;
+const getMobileFullscreenDimensions = () => ({
+    width: Math.max(MIN_WIDTH, window.innerWidth - MOBILE_EDGE_MARGIN * 2),
+    height: Math.max(MIN_HEIGHT, window.innerHeight - MOBILE_EDGE_MARGIN * 2),
+});
+export const useResizable = (currentPositionRef) => {
+    const resizeState = useRef(null);
+    const [positionAdjustment, setPositionAdjustment] = useState(null);
+    const [savedDimensions, setSavedDimensions, isDimensionsInitialized] = useLocalStorage('chat-window-dimensions', null);
+    const [isResizing, setIsResizing] = useState(false);
+    const clampDimensions = useCallback((width, height) => {
+        if (typeof window === 'undefined') {
+            return { width, height };
+        }
+        if (isMobileViewport()) {
+            return getMobileFullscreenDimensions();
+        }
+        const maxWidth = Math.max(MIN_WIDTH, window.innerWidth - VIEWPORT_MARGIN);
+        const maxHeight = Math.max(MIN_HEIGHT, window.innerHeight - VIEWPORT_MARGIN);
+        const clampedWidth = Math.min(Math.max(width, MIN_WIDTH), maxWidth);
+        let clampedHeight = clampedWidth / ASPECT_RATIO;
+        if (clampedHeight > maxHeight) {
+            clampedHeight = maxHeight;
+            const adjustedWidth = clampedHeight * ASPECT_RATIO;
+            return { width: adjustedWidth, height: clampedHeight };
+        }
+        if (clampedHeight < MIN_HEIGHT) {
+            clampedHeight = MIN_HEIGHT;
+            const adjustedWidth = clampedHeight * ASPECT_RATIO;
+            return { width: adjustedWidth, height: clampedHeight };
+        }
+        return { width: clampedWidth, height: clampedHeight };
+    }, []);
+    const calculateDimensions = useCallback((savedDims) => {
+        if (typeof window === 'undefined') {
+            return { width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT };
+        }
+        const baseDimensions = savedDims || { width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT };
+        return clampDimensions(baseDimensions.width, baseDimensions.height);
+    }, [clampDimensions]);
+    const [dimensions, setDimensions] = useState(() => {
+        if (typeof window === 'undefined') {
+            return { width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT };
+        }
+        if (isMobileViewport()) {
+            return getMobileFullscreenDimensions();
+        }
+        const maxWidth = Math.max(MIN_WIDTH, window.innerWidth - VIEWPORT_MARGIN);
+        const maxHeight = Math.max(MIN_HEIGHT, window.innerHeight - VIEWPORT_MARGIN);
+        let width = Math.min(Math.max(DEFAULT_WIDTH, MIN_WIDTH), maxWidth);
+        let height = width / ASPECT_RATIO;
+        if (height > maxHeight) {
+            height = maxHeight;
+            width = height * ASPECT_RATIO;
+        }
+        if (height < MIN_HEIGHT) {
+            height = MIN_HEIGHT;
+            width = height * ASPECT_RATIO;
+        }
+        return { width, height };
+    });
+    const hasLoadedFromStorage = useRef(false);
+    useEffect(() => {
+        if (isDimensionsInitialized && !hasLoadedFromStorage.current) {
+            const newDimensions = calculateDimensions(savedDimensions);
+            setDimensions(newDimensions);
+            hasLoadedFromStorage.current = true;
+        }
+    }, [isDimensionsInitialized, savedDimensions, calculateDimensions]);
+    const handleResizeStart = useCallback((corner) => (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        const currentPos = currentPositionRef?.current;
+        if (!currentPos) {
+            return;
+        }
+        const anchorTL = { x: currentPos.x, y: currentPos.y };
+        const anchorBR = {
+            x: currentPos.x + dimensions.width,
+            y: currentPos.y + dimensions.height
+        };
+        resizeState.current = { corner, anchorTL, anchorBR };
+        setIsResizing(true);
+        setPositionAdjustment(null);
+        document.body.style.userSelect = 'none';
+    }, [currentPositionRef, dimensions.width, dimensions.height]);
+    useEffect(() => {
+        if (!isResizing) {
+            return;
+        }
+        const handlePointerMove = (event) => {
+            const state = resizeState.current;
+            if (!state) {
+                return;
+            }
+            const { corner, anchorTL, anchorBR } = state;
+            const anchorBL = { x: anchorTL.x, y: anchorBR.y };
+            const anchorTR = { x: anchorBR.x, y: anchorTL.y };
+            let targetFromX;
+            let targetFromY;
+            switch (corner) {
+                case 'nw': {
+                    const deltaX = anchorBR.x - event.clientX;
+                    const deltaY = anchorBR.y - event.clientY;
+                    targetFromX = deltaX;
+                    targetFromY = deltaY * ASPECT_RATIO;
+                    break;
+                }
+                case 'se': {
+                    targetFromX = event.clientX - anchorTL.x;
+                    targetFromY = (event.clientY - anchorTL.y) * ASPECT_RATIO;
+                    break;
+                }
+                case 'ne': {
+                    targetFromX = event.clientX - anchorBL.x;
+                    targetFromY = (anchorBL.y - event.clientY) * ASPECT_RATIO;
+                    break;
+                }
+                case 'sw': {
+                    targetFromX = anchorTR.x - event.clientX;
+                    targetFromY = (event.clientY - anchorTR.y) * ASPECT_RATIO;
+                    break;
+                }
+                default:
+                    return;
+            }
+            const nextWidth = (targetFromX + targetFromY) / 2;
+            const newDimensions = clampDimensions(nextWidth, nextWidth / ASPECT_RATIO);
+            let newPos;
+            switch (corner) {
+                case 'nw':
+                    newPos = {
+                        x: anchorBR.x - newDimensions.width,
+                        y: anchorBR.y - newDimensions.height
+                    };
+                    break;
+                case 'se':
+                    newPos = { x: anchorTL.x, y: anchorTL.y };
+                    break;
+                case 'ne':
+                    newPos = {
+                        x: anchorBL.x,
+                        y: anchorBL.y - newDimensions.height
+                    };
+                    break;
+                case 'sw':
+                    newPos = {
+                        x: anchorTR.x - newDimensions.width,
+                        y: anchorTR.y
+                    };
+                    break;
+                default:
+                    newPos = anchorTL;
+            }
+            setDimensions(newDimensions);
+            setPositionAdjustment(newPos);
+        };
+        const handlePointerUp = () => {
+            setIsResizing(false);
+            resizeState.current = null;
+            setPositionAdjustment(null);
+            document.body.style.userSelect = '';
+        };
+        document.addEventListener('pointermove', handlePointerMove);
+        document.addEventListener('pointerup', handlePointerUp);
+        return () => {
+            document.removeEventListener('pointermove', handlePointerMove);
+            document.removeEventListener('pointerup', handlePointerUp);
+            document.body.style.userSelect = '';
+        };
+    }, [clampDimensions, isResizing]);
+    useEffect(() => {
+        if (!isResizing && isDimensionsInitialized && hasLoadedFromStorage.current) {
+            setSavedDimensions(dimensions);
+        }
+    }, [dimensions, isResizing, isDimensionsInitialized, setSavedDimensions]);
+    useEffect(() => {
+        const handleResize = () => {
+            setDimensions((current) => {
+                const clamped = clampDimensions(current.width, current.height);
+                return clamped;
+            });
+        };
+        window.addEventListener('resize', handleResize);
+        return () => window.removeEventListener('resize', handleResize);
+    }, [clampDimensions]);
+    return {
+        dimensions,
+        handleResizeStart,
+        positionAdjustment
+    };
+};

package/dist/legacy/core/lib/useSessionStorage.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, SetStateAction } from 'react';
+/**
+ * Custom hook for managing sessionStorage with React state
+ * Similar to useLocalStorage but uses sessionStorage instead
+ *
+ * @param key - The key to store the value under in sessionStorage
+ * @param defaultValue - The default value to use if no value is stored
+ * @returns [storedValue, setStoredValue, isInitialized]
+ */
+export default function useSessionStorage<T>(key: string, defaultValue: T): [T, Dispatch<SetStateAction<T>>, boolean];
+//# sourceMappingURL=useSessionStorage.d.ts.map

package/dist/legacy/core/lib/useSessionStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSessionStorage.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/lib/useSessionStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAuB,MAAM,OAAO,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,CAAC,EACzC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CA6B3C"}

package/dist/legacy/core/lib/useSessionStorage.js

@@ -0,0 +1,37 @@
+import { useEffect, useState } from 'react';
+/**
+ * Custom hook for managing sessionStorage with React state
+ * Similar to useLocalStorage but uses sessionStorage instead
+ *
+ * @param key - The key to store the value under in sessionStorage
+ * @param defaultValue - The default value to use if no value is stored
+ * @returns [storedValue, setStoredValue, isInitialized]
+ */
+export default function useSessionStorage(key, defaultValue) {
+    const [storedValue, setStoredValue] = useState(defaultValue);
+    const [isInitialized, setIsInitialized] = useState(false);
+    useEffect(() => {
+        try {
+            const storageValue = sessionStorage.getItem(key);
+            if (storageValue !== null) {
+                setStoredValue(JSON.parse(storageValue));
+            }
+        }
+        catch (error) {
+            console.warn(`Error reading from sessionStorage key "${key}":`, error);
+            // If there's an error, keep the default value
+        }
+        setIsInitialized(true);
+    }, [key]);
+    useEffect(() => {
+        if (isInitialized) {
+            try {
+                sessionStorage.setItem(key, JSON.stringify(storedValue));
+            }
+            catch (error) {
+                console.warn(`Error writing to sessionStorage key "${key}":`, error);
+            }
+        }
+    }, [storedValue, isInitialized, key]);
+    return [storedValue, setStoredValue, isInitialized];
+}

package/dist/legacy/core/lib/useSpeechToTextFromMic/helper.d.ts

@@ -0,0 +1,26 @@
+import { SpeechRecognizer } from 'microsoft-cognitiveservices-speech-sdk';
+import { Dispatch, SetStateAction } from 'react';
+/**
+ * Start speech recognition
+ * - partialTranscript: temporary partial transcription (recognizing)
+ * - setSpeechToTextArray: finalized sentence array (recognized)
+ */
+export declare const startSpeechToTextFromMic: (setSpeechToTextArray: Dispatch<SetStateAction<string[]>>, // finalized sentences
+config: {
+    apiKey: string;
+    apiSecret: string;
+}, historyRef: React.MutableRefObject<string[]>, indexRef: React.MutableRefObject<number>, setPartialTranscript?: Dispatch<SetStateAction<string>>) => Promise<SpeechRecognizer | undefined>;
+/**
+ * Stop speech recognition
+ */
+export declare const stopRecognition: (recognizer: SpeechRecognizer | undefined) => void;
+export declare function getTokenOrRefresh(apiKey: string, apiSecret: string): Promise<{
+    authToken: null;
+    error: string;
+    region?: undefined;
+} | {
+    authToken: any;
+    region: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=helper.d.ts.map

package/dist/legacy/core/lib/useSpeechToTextFromMic/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../../../../src/legacy/core/lib/useSpeechToTextFromMic/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,gBAAgB,EACjB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAIjD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,sBAAsB,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,EAAI,sBAAsB;AAClF,QAAQ;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAC7C,YAAY,KAAK,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAC5C,UAAU,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,EACxC,uBAAuB,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,KACtD,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAyEtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,gBAAgB,GAAG,SAAS,SAIvE,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;GAwBxE"}

package/dist/legacy/core/lib/useSpeechToTextFromMic/helper.js

@@ -0,0 +1,102 @@
+import { AudioConfig, CancellationReason, PropertyId, ResultReason, SpeechConfig, SpeechRecognizer, } from 'microsoft-cognitiveservices-speech-sdk';
+import Cookie from 'universal-cookie';
+import { createNxtlinqApi } from '../../../api/nxtlinq-api';
+/**
+ * Start speech recognition
+ * - partialTranscript: temporary partial transcription (recognizing)
+ * - setSpeechToTextArray: finalized sentence array (recognized)
+ */
+export const startSpeechToTextFromMic = async (setSpeechToTextArray, // finalized sentences
+config, historyRef, indexRef, setPartialTranscript // temporary partial transcription state updater
+) => {
+    const tokenRes = await getTokenOrRefresh(config.apiKey, config.apiSecret);
+    if (!tokenRes.authToken || !tokenRes.region) {
+        console.error('Speech token retrieval failed:', tokenRes.error);
+        return;
+    }
+    const speechConfig = SpeechConfig.fromAuthorizationToken(tokenRes.authToken, tokenRes.region);
+    speechConfig.speechRecognitionLanguage = 'en-US';
+    // silence detection and segmentation configuration
+    speechConfig.setProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, '10000');
+    speechConfig.setProperty(PropertyId.SpeechServiceConnection_EndSilenceTimeoutMs, '86400000');
+    speechConfig.setProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, '3000');
+    const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
+    const recognizer = new SpeechRecognizer(speechConfig, audioConfig);
+    // temporary partial transcription
+    recognizer.recognizing = (_s, e) => {
+        if (setPartialTranscript) {
+            setPartialTranscript(e.result.text);
+        }
+    };
+    // finalized sentences
+    recognizer.recognized = (_s, e) => {
+        if (e.result.reason === ResultReason.RecognizedSpeech) {
+            const text = e.result.text.trim();
+            // Filter out very short text (likely background noise or false positives)
+            // Minimum 3 characters to reduce sensitivity to background sounds
+            if (text.length < 3) {
+                return;
+            }
+            // Check confidence if available (some SDK versions provide this)
+            // Lower confidence results are more likely to be background noise
+            // Increased threshold to 0.4 to better filter out low-volume background noise
+            const confidence = e.result.confidence;
+            if (confidence !== undefined && confidence < 0.4) {
+                return;
+            }
+            historyRef.current[indexRef.current] = text;
+            indexRef.current += 1;
+            // return only the latest finalized sentence to the UI
+            setSpeechToTextArray([text]);
+            if (setPartialTranscript)
+                setPartialTranscript('');
+        }
+    };
+    recognizer.canceled = (_s, e) => {
+        console.warn('Speech recognition canceled:', e.reason);
+        if (e.reason === CancellationReason.Error) {
+            console.error(`Error code: ${e.errorCode}`);
+            console.error(`Error details: ${e.errorDetails}`);
+        }
+    };
+    await new Promise((resolve, reject) => {
+        recognizer.startContinuousRecognitionAsync(() => resolve(), error => {
+            console.error('Failed to start continuous speech recognition:', error);
+            reject(error);
+        });
+    });
+    return recognizer;
+};
+/**
+ * Stop speech recognition
+ */
+export const stopRecognition = (recognizer) => {
+    if (recognizer) {
+        recognizer.stopContinuousRecognitionAsync();
+    }
+};
+export async function getTokenOrRefresh(apiKey, apiSecret) {
+    const nxtlinqApi = createNxtlinqApi(apiKey, apiSecret);
+    const cookie = new Cookie();
+    const speechToken = cookie.get('speech-token');
+    if (speechToken === undefined) {
+        try {
+            const res = await nxtlinqApi.cognitive.getCognitiveToken();
+            if ('error' in res) {
+                throw new Error(res.error);
+            }
+            const token = res.token;
+            const region = res.region;
+            cookie.set('speech-token', region + ':' + token, { maxAge: 540, path: '/' });
+            return { authToken: token, region: region };
+        }
+        catch (e) {
+            const err = e;
+            return { authToken: null, error: err.response.data };
+        }
+    }
+    else {
+        const idx = speechToken.indexOf(':');
+        return { authToken: speechToken.slice(idx + 1), region: speechToken.slice(0, idx) };
+    }
+}

package/dist/legacy/core/lib/useSpeechToTextFromMic/index.d.ts

@@ -0,0 +1,16 @@
+interface Props {
+    apiKey: string;
+    apiSecret: string;
+    autoClearTranscript?: boolean;
+}
+type UseSpeechToTextFromMicResult = {
+    start: () => Promise<void>;
+    stop: () => void;
+    clear: () => void;
+    isMicEnabled: boolean;
+    transcript: string;
+    partialTranscript: string;
+};
+export declare function useSpeechToTextFromMic({ apiKey, apiSecret, autoClearTranscript, }: Props): UseSpeechToTextFromMicResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/legacy/core/lib/useSpeechToTextFromMic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/legacy/core/lib/useSpeechToTextFromMic/index.ts"],"names":[],"mappings":"AAIA,UAAU,KAAK;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,KAAK,4BAA4B,GAAG;IAClC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,SAAS,EACT,mBAA0B,GAC3B,EAAE,KAAK,GAAG,4BAA4B,CAsGtC"}

package/dist/legacy/core/lib/useSpeechToTextFromMic/index.js

@@ -0,0 +1,92 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { startSpeechToTextFromMic, stopRecognition } from './helper';
+export function useSpeechToTextFromMic({ apiKey, apiSecret, autoClearTranscript = true, }) {
+    const [isMicEnabled, setIsMicEnabled] = useState(false);
+    const [transcriptArray, setTranscriptArray] = useState([]);
+    const [partialTranscript, setPartialTranscript] = useState('');
+    const [recognizer, setRecognizer] = useState();
+    const wakelock = useRef();
+    const historyRef = useRef([]);
+    const indexRef = useRef(0);
+    const lockWakeState = useCallback(async () => {
+        if (typeof navigator === 'undefined' || !('wakeLock' in navigator))
+            return;
+        try {
+            wakelock.current = await navigator.wakeLock.request('screen');
+            wakelock.current.addEventListener('release', () => {
+                // Wake lock was released by the system
+            });
+        }
+        catch (err) {
+            console.error('Wake lock error:', err);
+        }
+    }, []);
+    const clear = useCallback(() => {
+        historyRef.current = [];
+        indexRef.current = 0;
+        setTranscriptArray([]);
+        setPartialTranscript('');
+    }, [setPartialTranscript, setTranscriptArray]);
+    const start = useCallback(async () => {
+        clear();
+        await lockWakeState();
+        try {
+            const recognizerInstance = await startSpeechToTextFromMic(setTranscriptArray, { apiKey, apiSecret }, historyRef, indexRef, setPartialTranscript);
+            setRecognizer(recognizerInstance);
+            setIsMicEnabled(true);
+        }
+        catch (error) {
+            wakelock.current?.release();
+            setIsMicEnabled(false);
+            console.error('Failed to start speech recognition:', error);
+            throw error;
+        }
+    }, [apiKey, apiSecret, clear, lockWakeState, setPartialTranscript, setTranscriptArray]);
+    const stop = useCallback(() => {
+        wakelock.current?.release();
+        stopRecognition(recognizer);
+        setIsMicEnabled(false);
+        setRecognizer(undefined);
+    }, [recognizer, setRecognizer]);
+    // Keep UI state in sync if recognizer stops or gets canceled by the SDK/browser
+    useEffect(() => {
+        if (!recognizer)
+            return;
+        const prevCanceled = recognizer.canceled;
+        const prevSessionStopped = recognizer.sessionStopped;
+        recognizer.canceled = (s, e) => {
+            setIsMicEnabled(false);
+            if (prevCanceled)
+                prevCanceled(s, e);
+        };
+        recognizer.sessionStopped = (s, e) => {
+            setIsMicEnabled(false);
+            if (prevSessionStopped)
+                prevSessionStopped(s, e);
+        };
+        return () => {
+            // No explicit detach API; restoring previous handlers to avoid leaks
+            if (recognizer) {
+                recognizer.canceled = prevCanceled;
+                recognizer.sessionStopped = prevSessionStopped;
+            }
+        };
+    }, [recognizer]);
+    useEffect(() => {
+        if (autoClearTranscript && transcriptArray.length > 0) {
+            const timer = setTimeout(() => {
+                setTranscriptArray([]);
+            }, 100);
+            return () => clearTimeout(timer);
+        }
+    }, [transcriptArray, autoClearTranscript]);
+    const transcript = transcriptArray.join(' ');
+    return {
+        start,
+        stop,
+        clear,
+        isMicEnabled,
+        transcript,
+        partialTranscript,
+    };
+}

package/dist/legacy/core/lib/useVoiceMode.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import type { AITApi, Message, VoiceTransport } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import { type VoiceStatus } from '../../api/voice';
+export type UseVoiceModeOptions = {
+    apiKey: string;
+    apiSecret: string;
+    pseudoId: string;
+    externalId?: string;
+    aitId?: string;
+    walletAddress?: string;
+    aitToken?: string;
+    metadata?: Record<string, unknown>;
+    nxtlinqApi: AITApi;
+    getMessages: () => Message[];
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    onError?: (error: Error) => void;
+    stopRecording: () => void;
+    stopTextToSpeech: () => void;
+    voiceTransport?: VoiceTransport;
+};
+export declare function useVoiceMode({ apiKey, apiSecret, pseudoId, externalId, aitId, walletAddress, aitToken, metadata, nxtlinqApi, getMessages, setMessages, onError, stopRecording, stopTextToSpeech, voiceTransport, }: UseVoiceModeOptions): {
+    isVoiceMode: boolean;
+    voiceStatus: VoiceStatus;
+    isVoiceConnecting: boolean;
+    isMicMuted: boolean;
+    remoteAudioRef: React.MutableRefObject<HTMLAudioElement | null>;
+    enterVoiceMode: () => Promise<void>;
+    exitVoiceMode: () => Promise<void>;
+    toggleMicMute: () => void;
+    interruptVoice: () => void;
+};
+//# sourceMappingURL=useVoiceMode.d.ts.map

package/dist/legacy/core/lib/useVoiceMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVoiceMode.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/lib/useVoiceMode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AACpG,OAAO,EAKL,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAgBzB,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,OAAO,EAAE,CAAC;IAC7B,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC7D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,wBAAgB,YAAY,CAAC,EAC3B,MAAM,EACN,SAAS,EACT,QAAQ,EACR,UAAU,EACV,KAAK,EACL,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,WAAW,EACX,OAAO,EACP,aAAa,EACb,gBAAgB,EAChB,cAA8B,GAC/B,EAAE,mBAAmB;;;;;;;;;;EA0VrB"}