@myscheme/voice-navigation-sdk 0.1.5 → 0.1.6

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"}

package/dist/services/azure-speech.js

@@ -1,9 +1,66 @@
 export class AzureSpeechService {
     constructor(config) {
-        this.subscriptionKey = config.subscriptionKey;
-        this.region = config.region;
+        this.tokenEndpoint = null;
+        this.subscriptionKey = null;
+        this.region = null;
+        this.useProxy = false;
+        this.cachedToken = null;
+        this.tokenExpiration = 0;
+        this.useProxy = !!config.tokenEndpoint;
+        if (this.useProxy) {
+            this.tokenEndpoint = config.tokenEndpoint || null;
+        }
+        else {
+            if (!config.subscriptionKey || !config.region) {
+                throw new Error("Azure subscription key and region required for direct mode");
+            }
+            this.subscriptionKey = config.subscriptionKey;
+            this.region = config.region;
+        }
     }
     async fetchToken() {
+        if (this.cachedToken && Date.now() < this.tokenExpiration) {
+            return {
+                token: this.cachedToken,
+                region: this.region || "centralindia",
+            };
+        }
+        if (this.useProxy) {
+            return this.fetchTokenViaProxy();
+        }
+        else {
+            return this.fetchTokenDirect();
+        }
+    }
+    async fetchTokenViaProxy() {
+        if (!this.tokenEndpoint) {
+            throw new Error("Token endpoint not configured");
+        }
+        try {
+            const response = await fetch(this.tokenEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch token: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            this.cachedToken = data.token;
+            this.tokenExpiration = Date.now() + 9 * 60 * 1000;
+            this.region = data.region;
+            return data;
+        }
+        catch (error) {
+            console.error("Failed to fetch Azure speech token via proxy:", error);
+            throw error;
+        }
+    }
+    async fetchTokenDirect() {
+        if (!this.subscriptionKey || !this.region) {
+            throw new Error("Azure subscription key and region not configured");
+        }
         const url = `https://${this.region}.api.cognitive.microsoft.com/sts/v1.0/issueToken`;
         try {
             const response = await fetch(url, {
@@ -17,9 +74,11 @@ export class AzureSpeechService {
                 throw new Error(`Failed to fetch token: ${response.status} ${response.statusText}`);
             }
             const token = await response.text();
+            this.cachedToken = token;
+            this.tokenExpiration = Date.now() + 9 * 60 * 1000;
             return {
                 token,
-                region: this.region,
+                region: this.region || "centralindia",
             };
         }
         catch (error) {
@@ -27,6 +86,10 @@ export class AzureSpeechService {
             throw error;
         }
     }
+    clearTokenCache() {
+        this.cachedToken = null;
+        this.tokenExpiration = 0;
+    }
     static create(config) {
         return new AzureSpeechService(config);
     }

package/dist/services/bedrock.d.ts

@@ -1,10 +1,12 @@
 import type { AgentActionResponse } from "../types.js";
 import type { PageRegistry } from "./page-registry.js";
 export interface BedrockConfig {
-    region: string;
-    accessKeyId: string;
-    secretAccessKey: string;
-    modelId: string;
+    bedrockEndpoint?: string;
+    embeddingEndpoint?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    modelId?: string;
     embeddingModelId?: string | null;
 }
 export declare class BedrockService {
@@ -12,11 +14,18 @@ export declare class BedrockService {
     private actionModelId;
     private embeddingModelId;
     private pageRegistry;
+    private bedrockEndpoint;
+    private embeddingEndpointUrl;
+    private useProxy;
     constructor(config: BedrockConfig);
     setPageRegistry(registry: PageRegistry): void;
     private buildSystemPrompt;
     extractAction(userInput: string): Promise<AgentActionResponse>;
+    private extractActionViaProxy;
+    private extractActionDirect;
     static create(config: BedrockConfig): BedrockService;
     embedText(text: string): Promise<number[]>;
+    private embedTextViaProxy;
+    private embedTextDirect;
 }
 //# sourceMappingURL=bedrock.d.ts.map

package/dist/services/bedrock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../src/services/bedrock.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAiCD,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,YAAY,CAA6B;gBAErC,MAAM,EAAE,aAAa;IAwBjC,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAO7C,OAAO,CAAC,iBAAiB;IA+BnB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAmEpE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc;IAO9C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAoFjD"}
+{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../src/services/bedrock.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,aAAa;IAE5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAG3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAmCD,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,MAAM,EAAE,aAAa;IA6CjC,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAO7C,OAAO,CAAC,iBAAiB;IA+BnB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;YAWtD,qBAAqB;YA2ErB,mBAAmB;IAyEjC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc;IAO9C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YAWlC,iBAAiB;YAkFjB,eAAe;CAoF9B"}

package/dist/services/bedrock.js

@@ -1,5 +1,5 @@
 import { BedrockRuntimeClient, InvokeModelCommand, } from "@aws-sdk/client-bedrock-runtime";
-const CORE_ACTIONS_LIST = `"zoom_in", "zoom_out", "scroll_up", "scroll_down", "scroll_left", "scroll_right", "page_up", "page_down", "scroll_top", "scroll_bottom", "go_back", "go_forward", "reload_page", "print_page", "copy_url", "open_menu", "close_menu", "focus_search", "toggle_fullscreen", "exit_fullscreen", "play_media", "pause_media", "mute_media", "unmute_media", "search_content", "stop"`;
+const CORE_ACTIONS_LIST = `"zoom_in", "zoom_out", "scroll_up", "scroll_down", "scroll_left", "scroll_right", "page_up", "page_down", "scroll_top", "scroll_bottom", "go_back", "go_forward", "reload_page", "print_page", "copy_url", "open_menu", "close_menu", "focus_search", "toggle_fullscreen", "exit_fullscreen", "play_media", "pause_media", "mute_media", "unmute_media", "search_content", "stop", "quit", "tab_next", "tab_back", "click", "enter", "submit", "move_left", "move_right", "move_up", "move_down", "move_beginning", "move_end", "select_all", "select_line", "type_text", "cut", "copy", "paste", "clear"`;
 const BASE_SYSTEM_PROMPT = `You are an action extraction assistant.
 
 CRITICAL RULES:
@@ -14,6 +14,7 @@ CRITICAL RULES:
 RESPONSE FORMAT:
 - Core actions: {"action": "action_name"}
 - Search: {"action": "search_content", "query": "keywords"}
+- Type text: {"action": "type_text", "text": "text to type"}
 - Page navigation: {"action": "navigate_<page_id>"}
 
 EXAMPLES:
@@ -21,6 +22,7 @@ EXAMPLES:
 - User says "show me the team page" → {"action": "navigate_team"}
 - User says "scroll down" → {"action": "scroll_down"}
 - User says "find schemes" → {"action": "search_content", "query": "schemes"}
+- User says "type hello world" → {"action": "type_text", "text": "hello world"}
 
 MATCHING RULES FOR PAGE NAVIGATION:
 - Match user's words to page names and keywords
@@ -29,25 +31,45 @@ MATCHING RULES FOR PAGE NAVIGATION:
 const DEFAULT_EMBEDDING_MODEL_ID = "cohere.embed-multilingual-v3";
 export class BedrockService {
     constructor(config) {
+        this.client = null;
+        this.actionModelId = null;
         this.pageRegistry = null;
-        this.client = new BedrockRuntimeClient({
-            region: config.region,
-            credentials: {
-                accessKeyId: config.accessKeyId,
-                secretAccessKey: config.secretAccessKey,
-            },
-        });
-        this.actionModelId = config.modelId;
-        if (config.embeddingModelId === null) {
+        this.bedrockEndpoint = null;
+        this.embeddingEndpointUrl = null;
+        this.useProxy = false;
+        this.useProxy = !!(config.bedrockEndpoint || config.embeddingEndpoint);
+        if (this.useProxy) {
+            this.bedrockEndpoint = config.bedrockEndpoint || null;
+            this.embeddingEndpointUrl = config.embeddingEndpoint || null;
+            this.actionModelId = null;
             this.embeddingModelId = null;
         }
-        else if (typeof config.embeddingModelId === "string") {
-            const trimmed = config.embeddingModelId.trim();
-            this.embeddingModelId =
-                trimmed.length > 0 ? trimmed : DEFAULT_EMBEDDING_MODEL_ID;
-        }
         else {
-            this.embeddingModelId = DEFAULT_EMBEDDING_MODEL_ID;
+            if (!config.region ||
+                !config.accessKeyId ||
+                !config.secretAccessKey ||
+                !config.modelId) {
+                throw new Error("AWS credentials required for direct mode");
+            }
+            this.client = new BedrockRuntimeClient({
+                region: config.region,
+                credentials: {
+                    accessKeyId: config.accessKeyId,
+                    secretAccessKey: config.secretAccessKey,
+                },
+            });
+            this.actionModelId = config.modelId;
+            if (config.embeddingModelId === null) {
+                this.embeddingModelId = null;
+            }
+            else if (typeof config.embeddingModelId === "string") {
+                const trimmed = config.embeddingModelId.trim();
+                this.embeddingModelId =
+                    trimmed.length > 0 ? trimmed : DEFAULT_EMBEDDING_MODEL_ID;
+            }
+            else {
+                this.embeddingModelId = DEFAULT_EMBEDDING_MODEL_ID;
+            }
         }
     }
     setPageRegistry(registry) {
@@ -71,6 +93,73 @@ export class BedrockService {
         return prompt;
     }
     async extractAction(userInput) {
+        if (this.useProxy) {
+            return this.extractActionViaProxy(userInput);
+        }
+        else {
+            return this.extractActionDirect(userInput);
+        }
+    }
+    async extractActionViaProxy(userInput) {
+        if (!this.bedrockEndpoint) {
+            throw new Error("Bedrock endpoint not configured");
+        }
+        try {
+            const systemPrompt = this.buildSystemPrompt();
+            const requestBody = {
+                anthropic_version: "bedrock-2023-05-31",
+                max_tokens: 70,
+                system: systemPrompt,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: `User input: "${userInput}". Identify the intended action from the allowed list and respond ONLY with a JSON object. If the user input is unclear, respond with {"action": "unknown"}. Include no additional text.`,
+                            },
+                        ],
+                    },
+                ],
+            };
+            const response = await fetch(this.bedrockEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    body: requestBody,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Bedrock proxy error: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            let rawText = "";
+            if (data.content && data.content.length > 0) {
+                rawText = data.content[0].text || "";
+            }
+            if (!rawText) {
+                return { action: "unknown" };
+            }
+            try {
+                const parsed = JSON.parse(rawText);
+                return parsed;
+            }
+            catch (parseError) {
+                console.error("Failed to parse Bedrock response:", rawText, parseError);
+                return { action: "unknown" };
+            }
+        }
+        catch (error) {
+            console.error("Bedrock proxy API error:", error);
+            throw error;
+        }
+    }
+    async extractActionDirect(userInput) {
+        if (!this.client || !this.actionModelId) {
+            throw new Error("AWS Bedrock client not initialized");
+        }
         const systemPrompt = this.buildSystemPrompt();
         const body = {
             anthropic_version: "bedrock-2023-05-31",
@@ -126,11 +215,76 @@ export class BedrockService {
         return new BedrockService(config);
     }
     async embedText(text) {
+        if (this.useProxy) {
+            return this.embedTextViaProxy(text);
+        }
+        else {
+            return this.embedTextDirect(text);
+        }
+    }
+    async embedTextViaProxy(text) {
+        const prompt = text.trim();
+        if (!prompt) {
+            return [];
+        }
+        if (!this.embeddingEndpointUrl) {
+            throw new Error("Embedding endpoint not configured");
+        }
+        try {
+            const response = await fetch(this.embeddingEndpointUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    text: prompt,
+                    inputType: "search_query",
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Embedding proxy error: ${response.status} ${response.statusText}`);
+            }
+            const decoded = (await response.json());
+            let embedding;
+            if (decoded.embeddings) {
+                if (Array.isArray(decoded.embeddings)) {
+                    if (decoded.embeddings.length > 0 &&
+                        Array.isArray(decoded.embeddings[0])) {
+                        embedding = decoded.embeddings[0];
+                    }
+                    else if (decoded.embeddings.length > 0 &&
+                        typeof decoded.embeddings[0] === "number") {
+                        embedding = decoded.embeddings;
+                    }
+                }
+                else if (typeof decoded.embeddings === "object" &&
+                    "values" in decoded.embeddings) {
+                    embedding = decoded.embeddings.values;
+                }
+            }
+            if (!embedding) {
+                embedding =
+                    decoded.embedding ||
+                        decoded.vector ||
+                        decoded.results?.find((item) => Array.isArray(item.embedding))
+                            ?.embedding;
+            }
+            if (!Array.isArray(embedding)) {
+                throw new Error("Unexpected embedding response structure");
+            }
+            return embedding.map((value) => Number(value));
+        }
+        catch (error) {
+            console.error("Embedding proxy error:", error);
+            throw error;
+        }
+    }
+    async embedTextDirect(text) {
         const prompt = text.trim();
         if (!prompt) {
             return [];
         }
-        if (!this.embeddingModelId) {
+        if (!this.client || !this.embeddingModelId) {
             throw new Error("Bedrock embedding model is not configured");
         }
         const payload = {

package/dist/services/vector-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector-search.d.ts","sourceRoot":"","sources":["../../src/services/vector-search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAwCD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,MAAM,EAAE,gBAAgB;IA6B9B,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAyF9E,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI;IAoCjD,oBAAoB,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG;QAC7C,GAAG,EAAE,eAAe,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;KACb,GAAG,IAAI;IAaR,OAAO,CAAC,mBAAmB;IAsB3B,OAAO,CAAC,eAAe;YAkBT,YAAY;CAQ3B"}
+{"version":3,"file":"vector-search.d.ts","sourceRoot":"","sources":["../../src/services/vector-search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAyCD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,MAAM,EAAE,gBAAgB;IAuC9B,MAAM,CACV,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,EAAE,CAAC;IA6F7B,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI;IAoCjD,oBAAoB,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG;QAC7C,GAAG,EAAE,eAAe,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC;KACb,GAAG,IAAI;IAaR,OAAO,CAAC,mBAAmB;IAqC3B,OAAO,CAAC,eAAe;YAqBT,YAAY;CAQ3B"}

package/dist/services/vector-search.js

@@ -11,6 +11,7 @@ export class VectorSearchService {
         const requestTimeoutMs = typeof config.requestTimeoutMs === "number" && config.requestTimeoutMs > 0
             ? Math.floor(config.requestTimeoutMs)
             : 15000;
+        const isEndpointOnlyMode = !!(config.searchEndpoint && !config.node);
         this.config = {
             ...config,
             vectorField: config.vectorField || "embedding",
@@ -19,9 +20,12 @@ export class VectorSearchService {
             numCandidates,
             requestTimeoutMs,
             sourceFields: config.sourceFields,
-            apiPath: config.apiPath || DEFAULT_VECTOR_SEARCH_API_PATH,
+            apiPath: config.apiPath ||
+                config.searchEndpoint ||
+                DEFAULT_VECTOR_SEARCH_API_PATH,
+            isEndpointOnlyMode,
         };
-        this.endpoint = this.resolveEndpoint(this.config.apiPath);
+        this.endpoint = this.resolveEndpoint(config.searchEndpoint || config.apiPath || DEFAULT_VECTOR_SEARCH_API_PATH);
     }
     async search(vector, queryText) {
         if (!Array.isArray(vector) || vector.length === 0) {
@@ -133,6 +137,15 @@ export class VectorSearchService {
         return null;
     }
     buildRequestPayload(vector, queryText) {
+        if (this.config.isEndpointOnlyMode) {
+            return {
+                vector,
+                query: queryText,
+                size: this.config.size,
+                minScore: this.config.minScore,
+                sourceFields: this.config.sourceFields,
+            };
+        }
         return {
             vector,
             queryText,