@myscheme/voice-navigation-sdk 0.1.5 → 0.1.7

package/dist/microphone-handler.js

@@ -10,6 +10,10 @@ export class MicrophoneHandler {
         this.hasPermission = false;
         this.audioContext = null;
         this.audioContextUnlocked = false;
+        this.activeCallbacks = {};
+        this.lastRecognitionTime = 0;
+        this.recognitionHealthCheckInterval = null;
+        this.isRecovering = false;
         this.azureSpeechService = config.azureSpeechService;
         this.bedrockService = config.bedrockService;
         this.language = config.language || "en-IN";
@@ -156,13 +160,69 @@ export class MicrophoneHandler {
     }
     scheduleSilenceCheck(callbacks = {}) {
         this.clearSilenceTimer();
+        const callbacksToUse = Object.keys(callbacks).length > 0 ? callbacks : this.activeCallbacks;
         this.silenceTimerId = setTimeout(() => {
             console.log("Silence detected - triggering callback");
-            if (callbacks.onSilence) {
-                callbacks.onSilence();
+            if (callbacksToUse.onSilence) {
+                callbacksToUse.onSilence();
             }
         }, this.silenceTimeout);
     }
+    rescheduleSilenceCheck() {
+        if (!this.isRecording) {
+            console.warn("[MicrophoneHandler] Cannot reschedule - not recording");
+            return;
+        }
+        if (!this.recognizer) {
+            console.error("[MicrophoneHandler] Cannot reschedule - no recognizer");
+            return;
+        }
+        console.log("[MicrophoneHandler] Rescheduling silence check");
+        this.scheduleSilenceCheck(this.activeCallbacks);
+    }
+    startHealthCheck() {
+        this.stopHealthCheck();
+        this.recognitionHealthCheckInterval = setInterval(() => {
+            const now = Date.now();
+            const timeSinceLastRecognition = now - this.lastRecognitionTime;
+            if (this.isRecording && timeSinceLastRecognition > 60000) {
+                console.warn("[MicrophoneHandler] Recognizer appears stalled. Last recognition:", timeSinceLastRecognition / 1000, "seconds ago");
+                this.recoverFromStalledRecognizer();
+            }
+        }, 30000);
+    }
+    stopHealthCheck() {
+        if (this.recognitionHealthCheckInterval) {
+            clearInterval(this.recognitionHealthCheckInterval);
+            this.recognitionHealthCheckInterval = null;
+        }
+    }
+    async recoverFromStalledRecognizer() {
+        if (this.isRecovering) {
+            console.log("[MicrophoneHandler] Recovery already in progress, skipping");
+            return;
+        }
+        this.isRecovering = true;
+        console.log("[MicrophoneHandler] Attempting to recover from stalled recognizer");
+        this.disposeRecognizer();
+        this.isRecording = false;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        try {
+            const restarted = await this.startRecording(this.activeCallbacks);
+            if (restarted) {
+                console.log("[MicrophoneHandler] Successfully recovered recognizer");
+            }
+            else {
+                console.error("[MicrophoneHandler] Failed to recover recognizer");
+            }
+        }
+        catch (error) {
+            console.error("[MicrophoneHandler] Error during recovery:", error);
+        }
+        finally {
+            this.isRecovering = false;
+        }
+    }
     async sendToBedrockAgent(text) {
         if (!text || !text.trim()) {
             return { action: "unknown" };
@@ -177,16 +237,17 @@ export class MicrophoneHandler {
         }
     }
     disposeRecognizer() {
+        this.stopHealthCheck();
         if (this.recognizer) {
             try {
                 this.recognizer.stopContinuousRecognitionAsync(() => {
-                    console.log("Recognizer stopped");
+                    console.log("[MicrophoneHandler] Recognizer stopped");
                     if (this.recognizer) {
                         this.recognizer.close();
                         this.recognizer = null;
                     }
                 }, (error) => {
-                    console.error("Error stopping recognizer:", error);
+                    console.error("[MicrophoneHandler] Error stopping recognizer:", error);
                     if (this.recognizer) {
                         this.recognizer.close();
                         this.recognizer = null;
@@ -194,7 +255,7 @@ export class MicrophoneHandler {
                 });
             }
             catch (error) {
-                console.error("Error disposing recognizer:", error);
+                console.error("[MicrophoneHandler] Error disposing recognizer:", error);
                 if (this.recognizer) {
                     this.recognizer.close();
                     this.recognizer = null;
@@ -213,9 +274,14 @@ export class MicrophoneHandler {
     }
     async startRecording(callbacks = {}) {
         if (this.isRecording) {
-            console.warn("Already recording");
+            console.warn("[MicrophoneHandler] Already recording");
+            return false;
+        }
+        if (this.isRecovering) {
+            console.warn("[MicrophoneHandler] Recovery in progress, cannot start");
             return false;
         }
+        this.activeCallbacks = callbacks;
         if (!this.hasPermission) {
             const granted = await this.requestMicrophonePermission();
             if (!granted) {
@@ -253,57 +319,65 @@ export class MicrophoneHandler {
             return false;
         }
         this.recognizer.recognizing = (_s, e) => {
-            if (e.result.text && callbacks.onPartial) {
-                callbacks.onPartial(e.result.text);
+            this.lastRecognitionTime = Date.now();
+            if (e.result.text && this.activeCallbacks.onPartial) {
+                this.activeCallbacks.onPartial(e.result.text);
             }
         };
         this.recognizer.recognized = (_s, e) => {
+            this.lastRecognitionTime = Date.now();
             if (e.result.reason === sdk.ResultReason.RecognizedSpeech) {
                 const text = e.result.text;
                 if (text) {
+                    console.log("[MicrophoneHandler] Recognized speech:", text);
                     this.transcriptionBuffer.push(text);
-                    if (callbacks.onSegment) {
-                        callbacks.onSegment(text, {
+                    if (this.activeCallbacks.onSegment) {
+                        this.activeCallbacks.onSegment(text, {
                             duration: e.result.duration,
                             offset: e.result.offset,
                         });
                     }
-                    this.scheduleSilenceCheck(callbacks);
+                    this.scheduleSilenceCheck(this.activeCallbacks);
                 }
             }
             else if (e.result.reason === sdk.ResultReason.NoMatch) {
-                console.log("No speech recognized");
+                console.log("[MicrophoneHandler] No speech recognized (NoMatch)");
             }
         };
         this.recognizer.canceled = (_s, e) => {
-            console.error("Recognition canceled:", e.reason, e.errorDetails);
+            console.error("[MicrophoneHandler] Recognition canceled:", e.reason, e.errorDetails);
             this.isRecording = false;
-            if (callbacks.onError) {
-                callbacks.onError(new Error(`Recognition canceled: ${e.reason} - ${e.errorDetails}`));
+            this.stopHealthCheck();
+            if (this.activeCallbacks.onError) {
+                this.activeCallbacks.onError(new Error(`Recognition canceled: ${e.reason} - ${e.errorDetails}`));
             }
         };
         this.recognizer.sessionStopped = (_s, _e) => {
-            console.log("Session stopped");
+            console.log("[MicrophoneHandler] Session stopped");
             this.isRecording = false;
+            this.stopHealthCheck();
         };
         this.recognizer.startContinuousRecognitionAsync(() => {
-            console.log("Continuous recognition started");
+            console.log("[MicrophoneHandler] Continuous recognition started");
             this.isRecording = true;
             this.audioContextUnlocked = true;
-            this.scheduleSilenceCheck(callbacks);
+            this.lastRecognitionTime = Date.now();
+            this.startHealthCheck();
+            this.scheduleSilenceCheck(this.activeCallbacks);
         }, (error) => {
-            console.error("Failed to start recognition:", error);
+            console.error("[MicrophoneHandler] Failed to start recognition:", error);
             this.isRecording = false;
-            if (callbacks.onError) {
-                callbacks.onError(new Error(`Failed to start recognition: ${error}`));
+            if (this.activeCallbacks.onError) {
+                this.activeCallbacks.onError(new Error(`Failed to start recognition: ${error}`));
             }
         });
         return true;
     }
     async stopRecording() {
         this.clearSilenceTimer();
+        this.stopHealthCheck();
         if (!this.isRecording || !this.recognizer) {
-            console.warn("Not currently recording");
+            console.warn("[MicrophoneHandler] Not currently recording");
             return this.getAggregatedText();
         }
         return new Promise((resolve) => {
@@ -312,13 +386,13 @@ export class MicrophoneHandler {
                 return;
             }
             this.recognizer.stopContinuousRecognitionAsync(() => {
-                console.log("Recognition stopped successfully");
+                console.log("[MicrophoneHandler] Recognition stopped successfully");
                 this.isRecording = false;
                 const finalText = this.getAggregatedText();
                 this.disposeRecognizer();
                 resolve(finalText);
             }, (error) => {
-                console.error("Error stopping recognition:", error);
+                console.error("[MicrophoneHandler] Error stopping recognition:", error);
                 this.isRecording = false;
                 const finalText = this.getAggregatedText();
                 this.disposeRecognizer();

package/dist/navigation-controller.d.ts

@@ -4,6 +4,7 @@ export declare class VoiceNavigationController {
     private microphoneHandler;
     private azureSpeechService;
     private bedrockService;
+    private voiceFeedbackService;
     private pageRegistry;
     private ui;
     private lastTranscript;
@@ -37,6 +38,9 @@ export declare class VoiceNavigationController {
     private processTranscript;
     private handleAgentResult;
     setLanguage(language: string): void;
+    setVoiceFeedback(enabled: boolean): void;
+    isVoiceFeedbackEnabled(): boolean;
+    private provideActionFeedback;
     private executeVectorSearchAction;
     private normalizeSearchQuery;
     private normalizeIndianSchemeName;

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

@@ -1 +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;AA2DpB,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,YAAY,CAAe;IACnC,OAAO,CAAC,EAAE,CAAc;IACxB,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;IAC/D,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,MAAM,EAAE,gBAAgB;YAkFtB,iBAAiB;IAiD/B,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;YAOtD,eAAe;IAmE7B,OAAO,CAAC,kBAAkB;YASZ,eAAe;IAwBhB,KAAK,CAChB,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GACzC,OAAO,CAAC,IAAI,CAAC;IAmFH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiClC,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,aAAa;YAWP,aAAa;YAOb,wBAAwB;IAuCtC,OAAO,CAAC,WAAW;YAoBL,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;IA8B1B,OAAO,CAAC,kBAAkB;IAwD1B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,wBAAwB;CAmBjC"}
+{"version":3,"file":"navigation-controller.d.ts","sourceRoot":"","sources":["../src/navigation-controller.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAMjB,MAAM,YAAY,CAAC;AA4DpB,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,oBAAoB,CAAuB;IACnD,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,EAAE,CAAc;IACxB,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;IAC/D,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,MAAM,EAAE,gBAAgB;YAqJtB,iBAAiB;IAiD/B,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;YAOtD,eAAe;IAmE7B,OAAO,CAAC,kBAAkB;YASZ,eAAe;IAwBhB,KAAK,CAChB,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAO,GACzC,OAAO,CAAC,IAAI,CAAC;IAmFH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiClC,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,aAAa;YAWP,aAAa;YAOb,wBAAwB;IA2CtC,OAAO,CAAC,WAAW;YAoBL,iBAAiB;YAwBjB,iBAAiB;IAoRxB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQnC,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAOxC,sBAAsB,IAAI,OAAO;YAO1B,qBAAqB;YAgFrB,yBAAyB;IAmMvC,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;IA8B1B,OAAO,CAAC,kBAAkB;IAwD1B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,wBAAwB;CAmBjC"}

package/dist/navigation-controller.js

@@ -2,6 +2,7 @@ import { MicrophoneHandler } from "./microphone-handler.js";
 import { AzureSpeechService } from "./services/azure-speech.js";
 import { BedrockService } from "./services/bedrock.js";
 import { PageRegistry } from "./services/page-registry.js";
+import { VoiceFeedbackService } from "./services/voice-feedback.js";
 import { loadNavigationPages } from "./services/xml-parser.js";
 import { VectorSearchService, } from "./services/vector-search.js";
 import { performAgentAction, formatActionLabel, extractAgentAction, setPageRegistry, } from "./actions.js";
@@ -43,19 +44,47 @@ export class VoiceNavigationController {
             opensearch: openSearchConfig,
         };
         console.log("[Voice Navigation Controller] Constructor called with UI config:", this.config.ui);
-        if (!this.config.azure?.subscriptionKey || !this.config.azure?.region) {
-            throw new Error("Azure Speech configuration is required");
+        const hasAzureEndpoint = !!this.config.azure?.tokenEndpoint;
+        const hasAzureCredentials = !!(this.config.azure?.subscriptionKey && this.config.azure?.region);
+        if (!this.config.azure) {
+            this.config.azure = { tokenEndpoint: "/api/speech/token" };
+            console.log("[VoiceNavigation] Auto-configured Azure endpoint: /api/speech/token");
+        }
+        else if (!hasAzureEndpoint && !hasAzureCredentials) {
+            this.config.azure.tokenEndpoint = "/api/speech/token";
+            console.log("[VoiceNavigation] Auto-configured Azure endpoint: /api/speech/token");
+        }
+        const hasAwsEndpoint = !!this.config.aws?.bedrockEndpoint;
+        const hasAwsCredentials = !!(this.config.aws?.accessKeyId &&
+            this.config.aws?.secretAccessKey &&
+            this.config.aws?.modelId);
+        if (!this.config.aws) {
+            this.config.aws = {
+                bedrockEndpoint: "/api/speech/bedrock",
+                embeddingEndpoint: "/api/speech/bedrock-embedding",
+            };
+            console.log("[VoiceNavigation] Auto-configured AWS endpoints: /api/speech/bedrock, /api/speech/bedrock-embedding");
+        }
+        else if (!hasAwsEndpoint && !hasAwsCredentials) {
+            this.config.aws.bedrockEndpoint = "/api/speech/bedrock";
+            this.config.aws.embeddingEndpoint = "/api/speech/bedrock-embedding";
+            console.log("[VoiceNavigation] Auto-configured AWS endpoints: /api/speech/bedrock, /api/speech/bedrock-embedding");
         }
-        if (!this.config.aws?.accessKeyId ||
-            !this.config.aws?.secretAccessKey ||
-            !this.config.aws?.modelId) {
-            throw new Error("AWS Bedrock configuration is required");
+        if (openSearchConfig &&
+            !openSearchConfig.searchEndpoint &&
+            !openSearchConfig.node) {
+            openSearchConfig.searchEndpoint = "/api/opensearch/search";
+            openSearchConfig.suggestEndpoint = "/api/opensearch/suggest";
+            console.log("[VoiceNavigation] Auto-configured OpenSearch endpoints: /api/opensearch/search, /api/opensearch/suggest");
         }
         this.azureSpeechService = new AzureSpeechService({
+            tokenEndpoint: this.config.azure.tokenEndpoint,
             subscriptionKey: this.config.azure.subscriptionKey,
             region: this.config.azure.region,
         });
         this.bedrockService = new BedrockService({
+            bedrockEndpoint: this.config.aws.bedrockEndpoint,
+            embeddingEndpoint: this.config.aws.embeddingEndpoint,
             region: this.config.aws.region || "ap-south-1",
             accessKeyId: this.config.aws.accessKeyId,
             secretAccessKey: this.config.aws.secretAccessKey,
@@ -71,6 +100,15 @@ export class VoiceNavigationController {
             bedrockService: this.bedrockService,
             language: this.config.language || "en-IN",
         });
+        const voiceFeedbackEnabled = this.config.voiceFeedback?.enabled !== false;
+        console.log("[VoiceNavigation] Initializing voice feedback service - enabled:", voiceFeedbackEnabled);
+        this.voiceFeedbackService = new VoiceFeedbackService({
+            enabled: voiceFeedbackEnabled,
+            language: this.config.language || "en-IN",
+            azureSpeechService: this.azureSpeechService,
+            bedrockService: this.bedrockService,
+        });
+        console.log("[VoiceNavigation] Voice feedback service initialized successfully");
         if (openSearchConfig) {
             try {
                 this.vectorSearchService = new VectorSearchService(openSearchConfig);
@@ -350,6 +388,7 @@ export class VoiceNavigationController {
             }
             updateTranscript(this.ui, "");
             this.isProcessing = false;
+            this.microphoneHandler.rescheduleSilenceCheck();
         }
     }
     handleError(error) {
@@ -410,6 +449,30 @@ export class VoiceNavigationController {
                 query,
                 originalText,
             });
+            if (actionResult.performed && actionResult.info?.pendingNavigation) {
+                console.log("[VoiceNavigation] Search result with navigation - waiting for feedback:", action);
+                try {
+                    await this.provideActionFeedback(action, actionResult, originalText);
+                    console.log("[VoiceNavigation] Search feedback complete, now navigating to:", actionResult.info.navigationUrl);
+                    if (actionResult.info.navigationUrl) {
+                        window.location.href = actionResult.info.navigationUrl;
+                        actionResult.info.navigated = true;
+                        actionResult.info.pendingNavigation = false;
+                    }
+                }
+                catch (err) {
+                    console.error("[VoiceNavigation] Voice feedback error (search):", err);
+                    if (actionResult.info.navigationUrl) {
+                        window.location.href = actionResult.info.navigationUrl;
+                    }
+                }
+            }
+            else if (actionResult.performed) {
+                console.log("[VoiceNavigation] Search result without navigation - non-blocking feedback");
+                void this.provideActionFeedback(action, actionResult, originalText).catch((err) => {
+                    console.error("[VoiceNavigation] Voice feedback error (search):", err);
+                });
+            }
             if (typeof this.config.actionHandlers?.[action] === "function") {
                 try {
                     this.config.actionHandlers[action]({
@@ -441,7 +504,80 @@ export class VoiceNavigationController {
             handler: this,
             onStop: () => this.stop(),
             transcript: originalText,
+            parameters: {
+                text: actionData.text || query,
+                query: query,
+            },
         });
+        console.log("[VoiceNavigation] Action performed:", action, "result:", actionResult.performed);
+        const isCriticalAction = action.startsWith("navigate_") ||
+            action === "focus_next" ||
+            action === "tab_next" ||
+            action === "focus_previous" ||
+            action === "tab_back" ||
+            action === "go_back" ||
+            action === "go_forward" ||
+            action === "reload_page";
+        if (actionResult.performed && isCriticalAction) {
+            console.log("[VoiceNavigation] Critical action - waiting for voice feedback to complete:", action);
+            try {
+                await this.provideActionFeedback(action, actionResult, originalText);
+                console.log("[VoiceNavigation] Voice feedback completed for critical action:", action);
+                if (actionResult.info?.pendingNavigation) {
+                    if (actionResult.info.navigationUrl) {
+                        console.log("[VoiceNavigation] Feedback complete, now navigating to:", actionResult.info.navigationUrl);
+                        window.location.href = actionResult.info.navigationUrl;
+                        actionResult.info.navigated = true;
+                        actionResult.info.pendingNavigation = false;
+                    }
+                    else if (actionResult.info.navigationType === "back") {
+                        console.log("[VoiceNavigation] Feedback complete, navigating back");
+                        window.history.back();
+                        actionResult.info.navigated = true;
+                        actionResult.info.pendingNavigation = false;
+                    }
+                    else if (actionResult.info.navigationType === "forward") {
+                        console.log("[VoiceNavigation] Feedback complete, navigating forward");
+                        window.history.forward();
+                        actionResult.info.navigated = true;
+                        actionResult.info.pendingNavigation = false;
+                    }
+                    else if (actionResult.info.navigationType === "reload") {
+                        console.log("[VoiceNavigation] Feedback complete, reloading page");
+                        window.location.reload();
+                        actionResult.info.reloaded = true;
+                        actionResult.info.pendingNavigation = false;
+                    }
+                }
+            }
+            catch (err) {
+                console.error("[VoiceNavigation] Voice feedback error (critical action):", err);
+                if (actionResult.info?.pendingNavigation) {
+                    if (actionResult.info.navigationUrl) {
+                        console.log("[VoiceNavigation] Feedback failed, but proceeding with navigation:", actionResult.info.navigationUrl);
+                        window.location.href = actionResult.info.navigationUrl;
+                    }
+                    else if (actionResult.info.navigationType === "back") {
+                        window.history.back();
+                    }
+                    else if (actionResult.info.navigationType === "forward") {
+                        window.history.forward();
+                    }
+                    else if (actionResult.info.navigationType === "reload") {
+                        window.location.reload();
+                    }
+                }
+            }
+        }
+        else if (actionResult.performed) {
+            console.log("[VoiceNavigation] Non-critical action - providing feedback non-blocking:", action);
+            void this.provideActionFeedback(action, actionResult, originalText).catch((err) => {
+                console.error("[VoiceNavigation] Voice feedback error:", err);
+            });
+        }
+        else {
+            console.log("[VoiceNavigation] Action not performed, skipping voice feedback");
+        }
         if (typeof this.config.actionHandlers?.[action] === "function") {
             try {
                 this.config.actionHandlers[action]({
@@ -470,6 +606,62 @@ export class VoiceNavigationController {
     }
     setLanguage(language) {
         this.microphoneHandler.setLanguage(language);
+        this.voiceFeedbackService.setLanguage(language);
+    }
+    setVoiceFeedback(enabled) {
+        this.voiceFeedbackService.setEnabled(enabled);
+    }
+    isVoiceFeedbackEnabled() {
+        return this.voiceFeedbackService.isEnabled();
+    }
+    async provideActionFeedback(action, actionResult, transcript) {
+        console.log("[VoiceNavigation] provideActionFeedback called for action:", action);
+        if (!this.voiceFeedbackService) {
+            console.error("[VoiceNavigation] Voice feedback service not initialized!");
+            return;
+        }
+        console.log("[VoiceNavigation] Voice feedback service exists, checking if enabled...");
+        console.log("[VoiceNavigation] Voice feedback enabled:", this.voiceFeedbackService.isEnabled());
+        try {
+            if (action.startsWith("navigate_") && actionResult.info?.pageName) {
+                console.log("[VoiceNavigation] Handling navigation feedback");
+                await this.voiceFeedbackService.provideFeedback({
+                    action,
+                    actionResult,
+                    transcript,
+                });
+                return;
+            }
+            if ((action === "focus_next" ||
+                action === "tab_next" ||
+                action === "focus_previous" ||
+                action === "tab_back") &&
+                actionResult.performed) {
+                console.log("[VoiceNavigation] Handling focus feedback");
+                const focusedElement = document.activeElement;
+                if (focusedElement && focusedElement !== document.body) {
+                    await this.voiceFeedbackService.announceFocusChange(focusedElement, actionResult.info.direction === "next" ||
+                        actionResult.info.direction === "forward"
+                        ? "next"
+                        : "previous");
+                    return;
+                }
+            }
+            if (actionResult.performed) {
+                console.log("[VoiceNavigation] Handling general action feedback");
+                await this.voiceFeedbackService.provideFeedback({
+                    action,
+                    actionResult,
+                    transcript,
+                });
+            }
+            else {
+                console.log("[VoiceNavigation] Action not performed in feedback check");
+            }
+        }
+        catch (error) {
+            console.error("[VoiceNavigation] Failed to provide voice feedback:", error);
+        }
     }
     async executeVectorSearchAction(options) {
         const vectorService = this.vectorSearchService;
@@ -595,7 +787,9 @@ export class VoiceNavigationController {
             });
             this.prepareForNavigation({ target: resolvedUrl });
             baseInfo.message = "Opening the best matching result.";
-            window.location.href = resolvedUrl;
+            baseInfo.pendingNavigation = true;
+            baseInfo.navigationUrl = resolvedUrl;
+            baseInfo.navigated = false;
             return {
                 performed: true,
                 info: baseInfo,

package/dist/server/azure-speech-handler.d.ts

@@ -0,0 +1,13 @@
+type NextApiRequest = {
+    method?: string;
+    body?: unknown;
+};
+type NextApiResponse = {
+    status: (code: number) => NextApiResponse;
+    json: (data: unknown) => void;
+    setHeader: (name: string, value: string | string[]) => void;
+};
+export declare function azureSpeechTokenHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export declare function POST(_request: Request): Promise<Response>;
+export {};
+//# sourceMappingURL=azure-speech-handler.d.ts.map

package/dist/server/azure-speech-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure-speech-handler.d.ts","sourceRoot":"","sources":["../../src/server/azure-speech-handler.ts"],"names":[],"mappings":"AAwBA,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAC1C,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;CAC7D,CAAC;AA6EF,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAqBf;AAMD,wBAAsB,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAmB/D"}

package/dist/server/azure-speech-handler.js

@@ -0,0 +1,79 @@
+async function getAzureSpeechToken() {
+    const key = process.env.AZURE_SPEECH_KEY;
+    const region = process.env.AZURE_SPEECH_REGION;
+    if (!key || !region) {
+        console.error("[VoiceNavigation] Missing Azure Speech credentials. Set AZURE_SPEECH_KEY and AZURE_SPEECH_REGION in your .env file");
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Azure Speech configuration is missing",
+                hint: "Set AZURE_SPEECH_KEY and AZURE_SPEECH_REGION environment variables",
+            },
+        };
+    }
+    try {
+        const url = `https://${region}.api.cognitive.microsoft.com/sts/v1.0/issueToken`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Ocp-Apim-Subscription-Key": key,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Azure API responded with status ${response.status}`);
+        }
+        const token = await response.text();
+        const responseData = { token, region };
+        return {
+            success: true,
+            statusCode: 200,
+            data: responseData,
+        };
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] Failed to fetch Azure speech token:", error);
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Failed to get token",
+                message: error instanceof Error ? error.message : "Unknown error",
+            },
+        };
+    }
+}
+export async function azureSpeechTokenHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    const result = await getAzureSpeechToken();
+    res.setHeader("Cache-Control", "no-store, no-cache, max-age=0, must-revalidate");
+    if (result.success && result.data) {
+        res.status(result.statusCode).json(result.data);
+    }
+    else {
+        res.status(result.statusCode).json(result.error);
+    }
+}
+export async function POST(_request) {
+    const result = await getAzureSpeechToken();
+    const headers = {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store, no-cache, max-age=0, must-revalidate",
+    };
+    if (result.success && result.data) {
+        return new Response(JSON.stringify(result.data), {
+            status: result.statusCode,
+            headers,
+        });
+    }
+    else {
+        return new Response(JSON.stringify(result.error), {
+            status: result.statusCode,
+            headers,
+        });
+    }
+}

package/dist/server/bedrock-embedding-handler.d.ts

@@ -0,0 +1,16 @@
+type NextApiRequest = {
+    method?: string;
+    body?: {
+        text?: string | string[];
+        inputType?: string;
+    };
+};
+type NextApiResponse = {
+    status: (code: number) => NextApiResponse;
+    json: (data: unknown) => void;
+    setHeader: (name: string, value: string | string[]) => void;
+};
+export declare function bedrockEmbeddingHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export declare function BedrockEmbeddingPOST(request: Request): Promise<Response>;
+export {};
+//# sourceMappingURL=bedrock-embedding-handler.d.ts.map

package/dist/server/bedrock-embedding-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock-embedding-handler.d.ts","sourceRoot":"","sources":["../../src/server/bedrock-embedding-handler.ts"],"names":[],"mappings":"AA4BA,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAC1C,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;CAC7D,CAAC;AA0MF,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAMD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAkCnB"}