@myscheme/voice-navigation-sdk 0.1.5 → 0.1.7

package/dist/server/bedrock-embedding-handler.js

@@ -0,0 +1,183 @@
+import crypto from "crypto";
+function sign(key, msg) {
+    return crypto.createHmac("sha256", key).update(msg, "utf8").digest();
+}
+function getSignatureKey(key, dateStamp, region, service) {
+    const kDate = sign("AWS4" + key, dateStamp);
+    const kRegion = sign(kDate, region);
+    const kService = sign(kRegion, service);
+    const kSigning = sign(kService, "aws4_request");
+    return kSigning;
+}
+async function generateBedrockEmbedding(text, inputType = "search_query") {
+    const region = process.env.AWS_REGION || "ap-south-1";
+    const accessKey = process.env.AWS_ACCESS_KEY_ID;
+    const secretKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const sessionToken = process.env.AWS_SESSION_TOKEN;
+    const embeddingModelId = process.env.AWS_EMBEDDING_MODEL_ID || "cohere.embed-multilingual-v3";
+    if (!accessKey || !secretKey) {
+        console.error("[VoiceNavigation] Missing AWS credentials. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in your .env file");
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Missing AWS credentials",
+                hint: "Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables",
+            },
+        };
+    }
+    if (!embeddingModelId) {
+        return {
+            success: false,
+            statusCode: 500,
+            error: { error: "Missing AWS_EMBEDDING_MODEL_ID" },
+        };
+    }
+    if (!text) {
+        return {
+            success: false,
+            statusCode: 400,
+            error: { error: "Missing text parameter" },
+        };
+    }
+    const requestBody = {
+        texts: Array.isArray(text) ? text : [text],
+        input_type: inputType,
+        truncate: "END",
+    };
+    const body = JSON.stringify(requestBody);
+    const service = "bedrock";
+    const host = `bedrock-runtime.${region}.amazonaws.com`;
+    const encodedModelId = encodeURIComponent(embeddingModelId);
+    const path = `/model/${encodedModelId}/invoke`;
+    const endpoint = `https://${host}${path}`;
+    const canonicalPath = path.replace(/%/g, "%25");
+    const amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, "");
+    const dateStamp = amzDate.slice(0, 8);
+    const headers = {
+        "content-type": "application/json",
+        host: host,
+        "x-amz-date": amzDate,
+    };
+    if (sessionToken) {
+        headers["x-amz-security-token"] = sessionToken;
+    }
+    const signedHeaders = Object.keys(headers)
+        .map((h) => h.toLowerCase())
+        .sort()
+        .join(";");
+    const canonicalHeaders = Object.keys(headers)
+        .map((h) => h.toLowerCase())
+        .sort()
+        .map((k) => `${k}:${headers[k]}\n`)
+        .join("");
+    const canonicalRequest = "POST\n" +
+        canonicalPath +
+        "\n" +
+        "\n" +
+        canonicalHeaders +
+        "\n" +
+        signedHeaders +
+        "\n" +
+        crypto.createHash("sha256").update(body, "utf8").digest("hex");
+    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+    const stringToSign = "AWS4-HMAC-SHA256\n" +
+        amzDate +
+        "\n" +
+        credentialScope +
+        "\n" +
+        crypto.createHash("sha256").update(canonicalRequest, "utf8").digest("hex");
+    const signingKey = getSignatureKey(secretKey, dateStamp, region, service);
+    const signature = crypto
+        .createHmac("sha256", signingKey)
+        .update(stringToSign, "utf8")
+        .digest("hex");
+    const authorizationHeader = `AWS4-HMAC-SHA256 Credential=${accessKey}/${credentialScope}, ` +
+        `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    const fetchHeaders = {
+        ...headers,
+        Authorization: authorizationHeader,
+    };
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: fetchHeaders,
+            body,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error("[VoiceNavigation] Bedrock Embedding API error:", response.status, errorText);
+            return {
+                success: false,
+                statusCode: response.status,
+                error: {
+                    error: "Bedrock Embedding API error",
+                    details: errorText,
+                },
+            };
+        }
+        const json = await response.json();
+        return {
+            success: true,
+            statusCode: 200,
+            data: json,
+        };
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] Bedrock embedding generation error:", error);
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Failed to generate embeddings",
+                message: error instanceof Error ? error.message : "Unknown error",
+            },
+        };
+    }
+}
+export async function bedrockEmbeddingHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    const { text, inputType = "search_query" } = req.body || {};
+    const result = await generateBedrockEmbedding(text, inputType);
+    if (result.success && result.data) {
+        res.status(result.statusCode).json(result.data);
+    }
+    else {
+        res.status(result.statusCode).json(result.error);
+    }
+}
+export async function BedrockEmbeddingPOST(request) {
+    try {
+        const body = await request.json();
+        const { text, inputType = "search_query" } = body || {};
+        const result = await generateBedrockEmbedding(text, inputType);
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        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,
+            });
+        }
+    }
+    catch (error) {
+        return new Response(JSON.stringify({
+            error: "Invalid request",
+            message: error instanceof Error ? error.message : "Unknown error",
+        }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock-handler.d.ts","sourceRoot":"","sources":["../../src/server/bedrock-handler.ts"],"names":[],"mappings":"AA4BA,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,OAAO,CAAC;KAChB,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;AAqLF,wBAAsB,cAAc,CAClC,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAMD,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkCrE"}

package/dist/server/bedrock-handler.js

@@ -0,0 +1,171 @@
+import crypto from "crypto";
+function sign(key, msg) {
+    return crypto.createHmac("sha256", key).update(msg, "utf8").digest();
+}
+function getSignatureKey(key, dateStamp, region, service) {
+    const kDate = sign("AWS4" + key, dateStamp);
+    const kRegion = sign(kDate, region);
+    const kService = sign(kRegion, service);
+    const kSigning = sign(kService, "aws4_request");
+    return kSigning;
+}
+async function invokeBedrock(requestBody) {
+    const region = process.env.AWS_REGION || "ap-south-1";
+    const accessKey = process.env.AWS_ACCESS_KEY_ID;
+    const secretKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const sessionToken = process.env.AWS_SESSION_TOKEN;
+    const modelId = process.env.AWS_MODEL_ID || "anthropic.claude-3-sonnet-20240229-v1:0";
+    if (!accessKey || !secretKey) {
+        console.error("[VoiceNavigation] Missing AWS credentials. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in your .env file");
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Missing AWS credentials",
+                hint: "Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables",
+            },
+        };
+    }
+    if (!requestBody) {
+        return {
+            success: false,
+            statusCode: 400,
+            error: { error: "Missing request body" },
+        };
+    }
+    const body = JSON.stringify(requestBody);
+    const service = "bedrock";
+    const host = `bedrock-runtime.${region}.amazonaws.com`;
+    const encodedModelId = encodeURIComponent(modelId);
+    const path = `/model/${encodedModelId}/invoke`;
+    const endpoint = `https://${host}${path}`;
+    const canonicalPath = path.replace(/%/g, "%25");
+    const amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, "");
+    const dateStamp = amzDate.slice(0, 8);
+    const headers = {
+        "content-type": "application/json",
+        host: host,
+        "x-amz-date": amzDate,
+    };
+    if (sessionToken) {
+        headers["x-amz-security-token"] = sessionToken;
+    }
+    const signedHeaders = Object.keys(headers)
+        .map((h) => h.toLowerCase())
+        .sort()
+        .join(";");
+    const canonicalHeaders = Object.keys(headers)
+        .map((h) => h.toLowerCase())
+        .sort()
+        .map((k) => `${k}:${headers[k]}\n`)
+        .join("");
+    const canonicalRequest = "POST\n" +
+        canonicalPath +
+        "\n" +
+        "\n" +
+        canonicalHeaders +
+        "\n" +
+        signedHeaders +
+        "\n" +
+        crypto.createHash("sha256").update(body, "utf8").digest("hex");
+    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+    const stringToSign = "AWS4-HMAC-SHA256\n" +
+        amzDate +
+        "\n" +
+        credentialScope +
+        "\n" +
+        crypto.createHash("sha256").update(canonicalRequest, "utf8").digest("hex");
+    const signingKey = getSignatureKey(secretKey, dateStamp, region, service);
+    const signature = crypto
+        .createHmac("sha256", signingKey)
+        .update(stringToSign, "utf8")
+        .digest("hex");
+    const authorizationHeader = `AWS4-HMAC-SHA256 Credential=${accessKey}/${credentialScope}, ` +
+        `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    const fetchHeaders = {
+        ...headers,
+        Authorization: authorizationHeader,
+    };
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: fetchHeaders,
+            body,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error("[VoiceNavigation] Bedrock API error:", response.status, errorText);
+            return {
+                success: false,
+                statusCode: response.status,
+                error: {
+                    error: "Bedrock API error",
+                    details: errorText,
+                },
+            };
+        }
+        const json = await response.json();
+        return {
+            success: true,
+            statusCode: 200,
+            data: json,
+        };
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] Bedrock action extraction error:", error);
+        return {
+            success: false,
+            statusCode: 500,
+            error: {
+                error: "Failed to extract action",
+                message: error instanceof Error ? error.message : "Unknown error",
+            },
+        };
+    }
+}
+export async function bedrockHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    const requestBody = req.body?.body;
+    const result = await invokeBedrock(requestBody);
+    if (result.success && result.data) {
+        res.status(result.statusCode).json(result.data);
+    }
+    else {
+        res.status(result.statusCode).json(result.error);
+    }
+}
+export async function BedrockPOST(request) {
+    try {
+        const body = await request.json();
+        const requestBody = body?.body;
+        const result = await invokeBedrock(requestBody);
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        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,
+            });
+        }
+    }
+    catch (error) {
+        return new Response(JSON.stringify({
+            error: "Invalid request",
+            message: error instanceof Error ? error.message : "Unknown error",
+        }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}

package/dist/server/index.d.ts

@@ -1,3 +1,10 @@
+export { azureSpeechTokenHandler } from "./azure-speech-handler.js";
+export { bedrockHandler } from "./bedrock-handler.js";
+export { bedrockEmbeddingHandler } from "./bedrock-embedding-handler.js";
+export { openSearchSearchHandler, openSearchSuggestHandler, } from "./opensearch-env-handler.js";
+export { POST } from "./azure-speech-handler.js";
+export { BedrockPOST } from "./bedrock-handler.js";
+export { BedrockEmbeddingPOST } from "./bedrock-embedding-handler.js";
 export { createOpenSearchProxyHandler, DEFAULT_OPENSEARCH_PROXY_PATH, } from "./opensearch-handler.js";
 export type { VectorSearchProxyRequest, VectorSearchProxyResponse, } from "./opensearch-handler.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAGtE,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC"}

package/dist/server/index.js

@@ -1 +1,8 @@
+export { azureSpeechTokenHandler } from "./azure-speech-handler.js";
+export { bedrockHandler } from "./bedrock-handler.js";
+export { bedrockEmbeddingHandler } from "./bedrock-embedding-handler.js";
+export { openSearchSearchHandler, openSearchSuggestHandler, } from "./opensearch-env-handler.js";
+export { POST } from "./azure-speech-handler.js";
+export { BedrockPOST } from "./bedrock-handler.js";
+export { BedrockEmbeddingPOST } from "./bedrock-embedding-handler.js";
 export { createOpenSearchProxyHandler, DEFAULT_OPENSEARCH_PROXY_PATH, } from "./opensearch-handler.js";

package/dist/server/opensearch-env-handler.d.ts

@@ -0,0 +1,22 @@
+type NextApiRequest = {
+    method?: string;
+    headers?: {
+        [key: string]: string | string[] | undefined;
+    };
+    body?: any;
+    query?: {
+        [key: string]: string | string[];
+    };
+    socket?: {
+        remoteAddress?: string;
+    };
+};
+type NextApiResponse = {
+    status: (code: number) => NextApiResponse;
+    json: (data: any) => void;
+    setHeader: (name: string, value: string | string[]) => void;
+};
+export declare function openSearchSearchHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export declare function openSearchSuggestHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export {};
+//# sourceMappingURL=opensearch-env-handler.d.ts.map

package/dist/server/opensearch-env-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opensearch-env-handler.d.ts","sourceRoot":"","sources":["../../src/server/opensearch-env-handler.ts"],"names":[],"mappings":"AAuBA,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;KAAE,CAAC;IAC3D,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;IAC7C,MAAM,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACrC,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAC1C,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAC1B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;CAC7D,CAAC;AAmFF,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CA6Hf;AAMD,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAgFf"}

package/dist/server/opensearch-env-handler.js

@@ -0,0 +1,221 @@
+const rateLimitMap = new Map();
+function checkRateLimit(identifier, maxRequests, windowMs) {
+    const now = Date.now();
+    const record = rateLimitMap.get(identifier);
+    if (!record || now > record.resetTime) {
+        rateLimitMap.set(identifier, {
+            count: 1,
+            resetTime: now + windowMs,
+        });
+        return true;
+    }
+    if (record.count >= maxRequests) {
+        return false;
+    }
+    record.count++;
+    return true;
+}
+function getClientIdentifier(req) {
+    const forwardedFor = req.headers?.["x-forwarded-for"];
+    if (forwardedFor) {
+        const ip = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor;
+        return ip.split(",")[0].trim();
+    }
+    const realIp = req.headers?.["x-real-ip"];
+    if (realIp) {
+        return Array.isArray(realIp) ? realIp[0] : realIp;
+    }
+    return req.socket?.remoteAddress || "unknown";
+}
+let opensearchClient = null;
+async function getOpenSearchClient() {
+    if (!opensearchClient) {
+        const node = process.env.OPENSEARCH_NODE;
+        const username = process.env.OPENSEARCH_USERNAME;
+        const password = process.env.OPENSEARCH_PASSWORD;
+        if (!node || !username || !password) {
+            throw new Error("OpenSearch configuration is missing. Set OPENSEARCH_NODE, OPENSEARCH_USERNAME, and OPENSEARCH_PASSWORD in your .env file");
+        }
+        const { Client } = await import("@opensearch-project/opensearch");
+        opensearchClient = new Client({
+            node: node,
+            auth: {
+                username: username,
+                password: password,
+            },
+            ssl: {
+                rejectUnauthorized: true,
+            },
+        });
+    }
+    return opensearchClient;
+}
+export async function openSearchSearchHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    const clientId = getClientIdentifier(req);
+    if (!checkRateLimit(clientId, 20, 60 * 1000)) {
+        res.status(429).json({
+            error: "Too many requests",
+            message: "Rate limit exceeded. Please try again later.",
+        });
+        return;
+    }
+    const { query, vector, size = 10 } = req.body || {};
+    if (!query || !vector) {
+        res.status(400).json({
+            error: "Missing required parameters",
+            hint: "Provide both 'query' and 'vector' in request body",
+        });
+        return;
+    }
+    if (typeof query !== "string" || query.length > 500) {
+        res.status(400).json({
+            error: "Invalid query parameter",
+            hint: "Query must be a string with max 500 characters",
+        });
+        return;
+    }
+    if (!Array.isArray(vector) || vector.length === 0) {
+        res.status(400).json({
+            error: "Invalid vector parameter",
+            hint: "Vector must be a non-empty array of numbers",
+        });
+        return;
+    }
+    try {
+        const client = await getOpenSearchClient();
+        const indexName = process.env.OPENSEARCH_INDEX;
+        const vectorField = process.env.OPENSEARCH_VECTOR_FIELD || "embedding";
+        if (!indexName) {
+            throw new Error("OPENSEARCH_INDEX environment variable is not set");
+        }
+        let searchResponse;
+        try {
+            searchResponse = await client.search({
+                index: indexName,
+                body: {
+                    size: Math.min(size, 100),
+                    query: {
+                        knn: {
+                            [vectorField]: {
+                                vector: vector,
+                                k: Math.min(size * 2, 200),
+                            },
+                        },
+                    },
+                    _source: ["name", "path", "keywords", "description"],
+                },
+            });
+        }
+        catch (knnError) {
+            const errorMessage = knnError?.message || "";
+            if (errorMessage.includes("is not knn_vector type") ||
+                errorMessage.includes("failed to create query") ||
+                errorMessage.includes("knn")) {
+                console.log(`[VoiceNavigation] Using text-based search (kNN vector search not available for field '${vectorField}')`);
+                searchResponse = await client.search({
+                    index: indexName,
+                    body: {
+                        size: Math.min(size, 100),
+                        query: {
+                            query_string: {
+                                query: query,
+                                default_operator: "OR",
+                                analyze_wildcard: true,
+                                lenient: true,
+                            },
+                        },
+                        _source: true,
+                    },
+                });
+            }
+            else {
+                throw knnError;
+            }
+        }
+        const hits = searchResponse.body.hits.hits.map((hit) => ({
+            id: hit._id,
+            score: hit._score,
+            source: hit._source,
+        }));
+        res.status(200).json({ hits });
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] OpenSearch search error:", error);
+        res.status(500).json({
+            error: "Search failed",
+            message: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+}
+export async function openSearchSuggestHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    const clientId = getClientIdentifier(req);
+    if (!checkRateLimit(clientId, 30, 60 * 1000)) {
+        res.status(429).json({
+            error: "Too many requests",
+            message: "Rate limit exceeded. Please try again later.",
+        });
+        return;
+    }
+    const { query } = req.body || {};
+    if (!query || typeof query !== "string") {
+        res.status(400).json({
+            error: "Missing or invalid query parameter",
+            hint: "Provide 'query' as a string in request body",
+        });
+        return;
+    }
+    if (query.length > 200) {
+        res.status(400).json({
+            error: "Query too long",
+            hint: "Query must be max 200 characters for suggestions",
+        });
+        return;
+    }
+    try {
+        const client = await getOpenSearchClient();
+        const indexName = process.env.OPENSEARCH_INDEX;
+        if (!indexName) {
+            throw new Error("OPENSEARCH_INDEX environment variable is not set");
+        }
+        const searchResponse = await client.search({
+            index: indexName,
+            body: {
+                size: 5,
+                query: {
+                    multi_match: {
+                        query: query,
+                        fields: ["name^3", "keywords^2", "description"],
+                        type: "bool_prefix",
+                        fuzziness: "AUTO",
+                    },
+                },
+                _source: ["name", "path", "keywords"],
+            },
+        });
+        const suggestions = searchResponse.body.hits.hits.map((hit) => ({
+            id: hit._id,
+            score: hit._score,
+            name: hit._source.name,
+            path: hit._source.path,
+            keywords: hit._source.keywords || [],
+        }));
+        res.status(200).json({ suggestions });
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] OpenSearch suggest error:", error);
+        res.status(500).json({
+            error: "Suggestion failed",
+            message: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+}

package/dist/services/azure-speech.d.ts

@@ -1,13 +1,21 @@
 import type { AzureTokenResponse } from "../types.js";
 export interface AzureSpeechConfig {
-    subscriptionKey: string;
-    region: string;
+    tokenEndpoint?: string;
+    subscriptionKey?: string;
+    region?: string;
 }
 export declare class AzureSpeechService {
+    private tokenEndpoint;
     private subscriptionKey;
     private region;
+    private useProxy;
+    private cachedToken;
+    private tokenExpiration;
     constructor(config: AzureSpeechConfig);
     fetchToken(): Promise<AzureTokenResponse>;
+    private fetchTokenViaProxy;
+    private fetchTokenDirect;
+    clearTokenCache(): void;
     static create(config: AzureSpeechConfig): AzureSpeechService;
 }
 //# sourceMappingURL=azure-speech.d.ts.map

package/dist/services/azure-speech.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"azure-speech.d.ts","sourceRoot":"","sources":["../../src/services/azure-speech.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,iBAAiB;IAQ/B,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAiC/C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,kBAAkB;CAG7D"}
+{"version":3,"file":"azure-speech.d.ts","sourceRoot":"","sources":["../../src/services/azure-speech.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAEhC,aAAa,CAAC,EAAE,MAAM,CAAC;IAGvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,eAAe,CAAa;gBAExB,MAAM,EAAE,iBAAiB;IAoB/B,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;YAmBjC,kBAAkB;YAoClB,gBAAgB;IAyC9B,eAAe,IAAI,IAAI;IAQvB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,kBAAkB;CAG7D"}