@myscheme/voice-navigation-sdk 0.1.0

package/dist/microphone-handler.d.ts

@@ -0,0 +1,47 @@
+import * as sdk from "microsoft-cognitiveservices-speech-sdk";
+import type { NavigationCallbacks, AgentActionResponse } from "./types.js";
+import { AzureSpeechService } from "./services/azure-speech.js";
+import { BedrockService } from "./services/bedrock.js";
+interface MicrophoneConfig {
+    azureSpeechService: AzureSpeechService;
+    bedrockService: BedrockService;
+    language?: string;
+    silenceTimeout?: number;
+}
+export declare class MicrophoneHandler {
+    private azureSpeechService;
+    private bedrockService;
+    private language;
+    private silenceTimeout;
+    private token;
+    private region;
+    private recognizer;
+    private transcriptionBuffer;
+    private silenceTimerId;
+    private isRecording;
+    private hasPermission;
+    private audioContext;
+    private audioContextUnlocked;
+    constructor(config: MicrophoneConfig);
+    hasMicrophonePermission(): boolean;
+    hasUnlockedAudioContext(): boolean;
+    getPermissionState(): Promise<PermissionState | "unknown">;
+    canStartAutomatically(): Promise<boolean>;
+    unlockAudioContext(isUserGesture: boolean): Promise<void>;
+    requestMicrophonePermission(): Promise<boolean>;
+    setLanguage(language: string): void;
+    resetTranscriptionBuffer(): void;
+    fetchAzureToken(): Promise<boolean>;
+    ensureSpeechSdk(): Promise<boolean>;
+    clearSilenceTimer(): void;
+    getAggregatedText(): string;
+    scheduleSilenceCheck(callbacks?: NavigationCallbacks): void;
+    sendToBedrockAgent(text: string): Promise<AgentActionResponse>;
+    disposeRecognizer(): void;
+    createRecognizer(): Promise<sdk.SpeechRecognizer>;
+    startRecording(callbacks?: NavigationCallbacks): Promise<boolean>;
+    stopRecording(): Promise<string>;
+    static isMicrophoneAvailable(): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=microphone-handler.d.ts.map

package/dist/microphone-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microphone-handler.d.ts","sourceRoot":"","sources":["../src/microphone-handler.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,GAAG,MAAM,wCAAwC,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,UAAU,gBAAgB;IACxB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,oBAAoB,CAAkB;gBAElC,MAAM,EAAE,gBAAgB;IAUpC,uBAAuB,IAAI,OAAO;IAIlC,uBAAuB,IAAI,OAAO;IAO5B,kBAAkB,IAAI,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAoB1D,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBzC,kBAAkB,CAAC,aAAa,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAwDzD,2BAA2B,IAAI,OAAO,CAAC,OAAO,CAAC;IA2BrD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYnC,wBAAwB,IAAI,IAAI;IAO1B,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBnC,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAkBzC,iBAAiB,IAAI,IAAI;IAUzB,iBAAiB,IAAI,MAAM;IAO3B,oBAAoB,CAAC,SAAS,GAAE,mBAAwB,GAAG,IAAI;IAczD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAiBpE,iBAAiB,IAAI,IAAI;IAgCnB,gBAAgB,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC;IAmBjD,cAAc,CAAC,SAAS,GAAE,mBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAiHrE,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;WAoCzB,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;CAYvD"}

package/dist/microphone-handler.js

@@ -0,0 +1,341 @@
+import * as sdk from "microsoft-cognitiveservices-speech-sdk";
+export class MicrophoneHandler {
+    constructor(config) {
+        this.token = null;
+        this.region = null;
+        this.recognizer = null;
+        this.transcriptionBuffer = [];
+        this.silenceTimerId = null;
+        this.isRecording = false;
+        this.hasPermission = false;
+        this.audioContext = null;
+        this.audioContextUnlocked = false;
+        this.azureSpeechService = config.azureSpeechService;
+        this.bedrockService = config.bedrockService;
+        this.language = config.language || "en-IN";
+        this.silenceTimeout = config.silenceTimeout || 2000;
+    }
+    hasMicrophonePermission() {
+        return this.hasPermission;
+    }
+    hasUnlockedAudioContext() {
+        return this.audioContextUnlocked;
+    }
+    async getPermissionState() {
+        if (typeof navigator === "undefined" || !navigator.permissions) {
+            return "unknown";
+        }
+        try {
+            const result = await navigator.permissions.query({
+                name: "microphone",
+            });
+            return result.state;
+        }
+        catch (error) {
+            console.warn("Failed to query microphone permission state:", error);
+            return "unknown";
+        }
+    }
+    async canStartAutomatically() {
+        if (this.hasPermission) {
+            return true;
+        }
+        const state = await this.getPermissionState();
+        if (state !== "granted") {
+            return false;
+        }
+        return this.audioContextUnlocked;
+    }
+    async unlockAudioContext(isUserGesture) {
+        if (this.audioContextUnlocked) {
+            return;
+        }
+        if (!isUserGesture) {
+            return;
+        }
+        if (typeof window === "undefined") {
+            return;
+        }
+        const globalWindow = window;
+        const AudioContextCtor = globalWindow.AudioContext || globalWindow.webkitAudioContext;
+        if (!AudioContextCtor) {
+            this.audioContextUnlocked = true;
+            return;
+        }
+        if (!this.audioContext) {
+            try {
+                this.audioContext = new AudioContextCtor();
+            }
+            catch (error) {
+                console.warn("Failed to create AudioContext:", error);
+                throw error;
+            }
+        }
+        try {
+            if (this.audioContext.state === "suspended") {
+                await this.audioContext.resume();
+            }
+            else if (this.audioContext.state === "closed") {
+                this.audioContext = new AudioContextCtor();
+                if (this.audioContext.state === "suspended") {
+                    await this.audioContext.resume();
+                }
+            }
+            if (this.audioContext.state === "running") {
+                this.audioContextUnlocked = true;
+            }
+        }
+        catch (error) {
+            console.warn("Failed to resume AudioContext:", error);
+            throw error;
+        }
+    }
+    async requestMicrophonePermission() {
+        if (typeof navigator === "undefined" || !navigator.mediaDevices) {
+            console.error("MediaDevices not supported");
+            return false;
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+            });
+            stream.getTracks().forEach((track) => track.stop());
+            this.hasPermission = true;
+            console.log("Microphone permission granted");
+            return true;
+        }
+        catch (error) {
+            console.error("Microphone permission denied:", error);
+            this.hasPermission = false;
+            return false;
+        }
+    }
+    setLanguage(language) {
+        if (!language) {
+            console.warn("Invalid language code");
+            return;
+        }
+        this.language = language;
+        console.log(`Speech recognition language set to: ${language}`);
+    }
+    resetTranscriptionBuffer() {
+        this.transcriptionBuffer = [];
+    }
+    async fetchAzureToken() {
+        try {
+            const response = await this.azureSpeechService.fetchToken();
+            this.token = response.token;
+            this.region = response.region;
+            console.log("Azure token fetched successfully");
+            return true;
+        }
+        catch (error) {
+            console.error("Failed to fetch Azure token:", error);
+            throw error;
+        }
+    }
+    async ensureSpeechSdk() {
+        if (typeof window === "undefined") {
+            console.error("Speech SDK requires browser environment");
+            return false;
+        }
+        if (typeof sdk !== "undefined") {
+            return true;
+        }
+        console.error("Speech SDK not available");
+        return false;
+    }
+    clearSilenceTimer() {
+        if (this.silenceTimerId) {
+            clearTimeout(this.silenceTimerId);
+            this.silenceTimerId = null;
+        }
+    }
+    getAggregatedText() {
+        return this.transcriptionBuffer.join(" ").trim();
+    }
+    scheduleSilenceCheck(callbacks = {}) {
+        this.clearSilenceTimer();
+        this.silenceTimerId = setTimeout(() => {
+            console.log("Silence detected - triggering callback");
+            if (callbacks.onSilence) {
+                callbacks.onSilence();
+            }
+        }, this.silenceTimeout);
+    }
+    async sendToBedrockAgent(text) {
+        if (!text || !text.trim()) {
+            return { action: "unknown" };
+        }
+        try {
+            const response = await this.bedrockService.extractAction(text);
+            return response;
+        }
+        catch (error) {
+            console.error("Bedrock agent error:", error);
+            throw error;
+        }
+    }
+    disposeRecognizer() {
+        if (this.recognizer) {
+            try {
+                this.recognizer.stopContinuousRecognitionAsync(() => {
+                    console.log("Recognizer stopped");
+                    if (this.recognizer) {
+                        this.recognizer.close();
+                        this.recognizer = null;
+                    }
+                }, (error) => {
+                    console.error("Error stopping recognizer:", error);
+                    if (this.recognizer) {
+                        this.recognizer.close();
+                        this.recognizer = null;
+                    }
+                });
+            }
+            catch (error) {
+                console.error("Error disposing recognizer:", error);
+                if (this.recognizer) {
+                    this.recognizer.close();
+                    this.recognizer = null;
+                }
+            }
+        }
+    }
+    async createRecognizer() {
+        if (!this.token || !this.region) {
+            throw new Error("Azure token not available");
+        }
+        const speechConfig = sdk.SpeechConfig.fromAuthorizationToken(this.token, this.region);
+        speechConfig.speechRecognitionLanguage = this.language;
+        const audioConfig = sdk.AudioConfig.fromDefaultMicrophoneInput();
+        return new sdk.SpeechRecognizer(speechConfig, audioConfig);
+    }
+    async startRecording(callbacks = {}) {
+        if (this.isRecording) {
+            console.warn("Already recording");
+            return false;
+        }
+        if (!this.hasPermission) {
+            const granted = await this.requestMicrophonePermission();
+            if (!granted) {
+                if (callbacks.onError) {
+                    callbacks.onError(new Error("Microphone permission denied"));
+                }
+                return false;
+            }
+        }
+        const sdkReady = await this.ensureSpeechSdk();
+        if (!sdkReady) {
+            if (callbacks.onError) {
+                callbacks.onError(new Error("Speech SDK not available"));
+            }
+            return false;
+        }
+        try {
+            await this.fetchAzureToken();
+        }
+        catch (error) {
+            if (callbacks.onError) {
+                callbacks.onError(error);
+            }
+            return false;
+        }
+        this.resetTranscriptionBuffer();
+        try {
+            this.recognizer = await this.createRecognizer();
+        }
+        catch (error) {
+            console.error("Failed to create recognizer:", error);
+            if (callbacks.onError) {
+                callbacks.onError(error);
+            }
+            return false;
+        }
+        this.recognizer.recognizing = (_s, e) => {
+            if (e.result.text && callbacks.onPartial) {
+                callbacks.onPartial(e.result.text);
+            }
+        };
+        this.recognizer.recognized = (_s, e) => {
+            if (e.result.reason === sdk.ResultReason.RecognizedSpeech) {
+                const text = e.result.text;
+                if (text) {
+                    this.transcriptionBuffer.push(text);
+                    if (callbacks.onSegment) {
+                        callbacks.onSegment(text, {
+                            duration: e.result.duration,
+                            offset: e.result.offset,
+                        });
+                    }
+                    this.scheduleSilenceCheck(callbacks);
+                }
+            }
+            else if (e.result.reason === sdk.ResultReason.NoMatch) {
+                console.log("No speech recognized");
+            }
+        };
+        this.recognizer.canceled = (_s, e) => {
+            console.error("Recognition canceled:", e.reason, e.errorDetails);
+            this.isRecording = false;
+            if (callbacks.onError) {
+                callbacks.onError(new Error(`Recognition canceled: ${e.reason} - ${e.errorDetails}`));
+            }
+        };
+        this.recognizer.sessionStopped = (_s, _e) => {
+            console.log("Session stopped");
+            this.isRecording = false;
+        };
+        this.recognizer.startContinuousRecognitionAsync(() => {
+            console.log("Continuous recognition started");
+            this.isRecording = true;
+            this.audioContextUnlocked = true;
+            this.scheduleSilenceCheck(callbacks);
+        }, (error) => {
+            console.error("Failed to start recognition:", error);
+            this.isRecording = false;
+            if (callbacks.onError) {
+                callbacks.onError(new Error(`Failed to start recognition: ${error}`));
+            }
+        });
+        return true;
+    }
+    async stopRecording() {
+        this.clearSilenceTimer();
+        if (!this.isRecording || !this.recognizer) {
+            console.warn("Not currently recording");
+            return this.getAggregatedText();
+        }
+        return new Promise((resolve) => {
+            if (!this.recognizer) {
+                resolve(this.getAggregatedText());
+                return;
+            }
+            this.recognizer.stopContinuousRecognitionAsync(() => {
+                console.log("Recognition stopped successfully");
+                this.isRecording = false;
+                const finalText = this.getAggregatedText();
+                this.disposeRecognizer();
+                resolve(finalText);
+            }, (error) => {
+                console.error("Error stopping recognition:", error);
+                this.isRecording = false;
+                const finalText = this.getAggregatedText();
+                this.disposeRecognizer();
+                resolve(finalText);
+            });
+        });
+    }
+    static async isMicrophoneAvailable() {
+        if (typeof navigator === "undefined" || !navigator.mediaDevices) {
+            return false;
+        }
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.some((device) => device.kind === "audioinput");
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/navigation-controller.d.ts

@@ -0,0 +1,50 @@
+import type { NavigationConfig } from "./types.js";
+export declare class VoiceNavigationController {
+    private config;
+    private microphoneHandler;
+    private azureSpeechService;
+    private bedrockService;
+    private ui;
+    private lastTranscript;
+    private isProcessing;
+    private resumeAfterNavigation;
+    private lastStartReason;
+    private autoStartPendingUserInteraction;
+    private removeAutoStartListeners;
+    private vectorSearchService;
+    constructor(config: NavigationConfig);
+    private shouldAutoStart;
+    setAutoStart(enabled: boolean): void;
+    prepareForNavigation(options?: {
+        target?: string;
+    }): void;
+    private setupEventHandlers;
+    private toggleRecording;
+    start(options?: {
+        reason?: "auto" | "user";
+    }): Promise<void>;
+    stop(): Promise<void>;
+    private handlePartial;
+    private handleSegment;
+    private handleSilence;
+    private processPendingTranscript;
+    private handleError;
+    private processTranscript;
+    private handleAgentResult;
+    setLanguage(language: string): void;
+    private executeVectorSearchAction;
+    private normalizeSearchQuery;
+    private normalizeIndianSchemeName;
+    private resolveUrl;
+    private isSameDomain;
+    private safeHostname;
+    private pauseAfterExternalNavigation;
+    destroy(): void;
+    private persistResumeState;
+    private consumeResumeState;
+    private isActiveState;
+    private handleAutoStartFallback;
+    private clearAutoStartFallback;
+    private isPermissionRelatedError;
+}
+//# sourceMappingURL=navigation-controller.d.ts.map

package/dist/navigation-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-controller.d.ts","sourceRoot":"","sources":["../src/navigation-controller.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAKjB,MAAM,YAAY,CAAC;AAuDpB,qBAAa,yBAAyB;IACpC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,EAAE,CAAa;IACvB,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,qBAAqB,CAAkB;IAC/C,OAAO,CAAC,eAAe,CAA2B;IAClD,OAAO,CAAC,+BAA+B,CAAkB;IACzD,OAAO,CAAC,wBAAwB,CAA6B;IAC7D,OAAO,CAAC,mBAAmB,CAAoC;gBAEnD,MAAM,EAAE,gBAAgB;IA0EpC,OAAO,CAAC,eAAe;IAoBhB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAepC,oBAAoB,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,IAAI;IAOpE,OAAO,CAAC,kBAAkB;YASZ,eAAe;IAkBhB,KAAK,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAiEhE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BlC,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,aAAa;YAWP,aAAa;YAOb,wBAAwB;IAuCtC,OAAO,CAAC,WAAW;YAiBL,iBAAiB;YAwBjB,iBAAiB;IA0HxB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;YAI5B,yBAAyB;IAgMvC,OAAO,CAAC,oBAAoB;IAqD5B,OAAO,CAAC,yBAAyB;IAoCjC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,4BAA4B;IAiB7B,OAAO,IAAI,IAAI;IAgBtB,OAAO,CAAC,kBAAkB;IA+B1B,OAAO,CAAC,kBAAkB;IAwD1B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,uBAAuB;IAoD/B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,wBAAwB;CAgBjC"}