@myscheme/voice-navigation-sdk 0.1.0

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +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"}

package/dist/server/index.js

@@ -0,0 +1 @@
+export { createOpenSearchProxyHandler, DEFAULT_OPENSEARCH_PROXY_PATH, } from "./opensearch-handler.js";

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

@@ -0,0 +1,52 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import type { OpenSearchConfig } from "../types.js";
+interface OpenSearchCredentials {
+    node: string;
+    username: string;
+    password: string;
+    ssl?: OpenSearchConfig["ssl"];
+}
+interface VectorSearchParams {
+    index: string;
+    vectorField: string;
+    size: number;
+    numCandidates: number;
+    minScore: number;
+    sourceFields?: string[];
+    queryText?: string;
+}
+export interface VectorSearchProxyRequest {
+    vector: number[];
+    credentials: OpenSearchCredentials;
+    params: VectorSearchParams;
+    queryText?: string;
+}
+export interface VectorSearchProxyResponse {
+    hits: Array<{
+        id: string;
+        score: number;
+        source: Record<string, unknown>;
+    }>;
+}
+type CompatibleRequest = IncomingMessage & {
+    body?: unknown;
+    method?: string;
+};
+type CompatibleResponse = ServerResponse & {
+    status?: (code: number) => CompatibleResponse;
+    json?: (payload: unknown) => void;
+    setHeader: (name: string, value: string) => void;
+};
+interface CreateOpenSearchProxyHandlerOptions {
+    allowedOrigins?: string[];
+    cacheClients?: boolean;
+    requestTimeoutMs?: number;
+    logger?: {
+        error: (message: string, meta?: Record<string, unknown>) => void;
+        info?: (message: string, meta?: Record<string, unknown>) => void;
+    };
+}
+export declare const DEFAULT_OPENSEARCH_PROXY_PATH = "/api/voice-navigation/vector-search";
+export declare const createOpenSearchProxyHandler: (options?: CreateOpenSearchProxyHandlerOptions) => (req: CompatibleRequest, res: CompatibleResponse) => Promise<void>;
+export {};
+//# sourceMappingURL=opensearch-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opensearch-handler.d.ts","sourceRoot":"","sources":["../../src/server/opensearch-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAG5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,UAAU,qBAAqB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;CAC/B;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,qBAAqB,CAAC;IACnC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,KAAK,CAAC;QACV,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACjC,CAAC,CAAC;CACJ;AAED,KAAK,iBAAiB,GAAG,eAAe,GAAG;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,kBAAkB,GAAG,cAAc,GAAG;IACzC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,kBAAkB,CAAC;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD,CAAC;AAEF,UAAU,mCAAmC;IAC3C,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE;QACP,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;QACjE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;KAClE,CAAC;CACH;AA4RD,eAAO,MAAM,6BAA6B,wCAAiC,CAAC;AAE5E,eAAO,MAAM,4BAA4B,GACvC,UAAS,mCAAwC,MAMnC,KAAK,iBAAiB,EAAE,KAAK,kBAAkB,KAAG,OAAO,CAAC,IAAI,CA6D7E,CAAC"}

package/dist/server/opensearch-handler.js

@@ -0,0 +1,279 @@
+import { Client } from "@opensearch-project/opensearch";
+import { DEFAULT_VECTOR_SEARCH_API_PATH } from "../constants.js";
+const defaultLogger = {
+    error: (message, meta) => {
+        console.error(`[VoiceNavigation][OpenSearchProxy] ${message}`, meta);
+    },
+    info: (message, meta) => {
+        console.log(`[VoiceNavigation][OpenSearchProxy] ${message}`, meta);
+    },
+};
+const CLIENT_CACHE = new Map();
+const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
+const normalizeRequestTimeoutMs = (value) => {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    return DEFAULT_REQUEST_TIMEOUT_MS;
+};
+const getClientCacheKey = (credentials, requestTimeoutMs) => {
+    return `${normalizeOpenSearchNode(credentials.node)}::${credentials.username}::${requestTimeoutMs}`;
+};
+const getCachedClient = (credentials, requestTimeoutMs, cacheEnabled) => {
+    if (!cacheEnabled) {
+        return createClient(credentials, requestTimeoutMs);
+    }
+    const key = getClientCacheKey(credentials, requestTimeoutMs);
+    const existing = CLIENT_CACHE.get(key);
+    if (existing) {
+        return existing;
+    }
+    const client = createClient(credentials, requestTimeoutMs);
+    CLIENT_CACHE.set(key, client);
+    return client;
+};
+const createClient = (credentials, requestTimeoutMs) => {
+    return new Client({
+        node: normalizeOpenSearchNode(credentials.node),
+        auth: {
+            username: credentials.username,
+            password: credentials.password,
+        },
+        ssl: credentials.ssl,
+        requestTimeout: requestTimeoutMs,
+    });
+};
+const normalizeOpenSearchNode = (node) => {
+    if (!node || typeof node !== "string") {
+        return node;
+    }
+    try {
+        const parsed = new URL(node);
+        if (!parsed.username && !parsed.password) {
+            return node;
+        }
+        parsed.username = "";
+        parsed.password = "";
+        return parsed.toString();
+    }
+    catch {
+        return node;
+    }
+};
+const parseJsonBody = async (req) => {
+    if (req.body) {
+        if (typeof req.body === "string") {
+            return req.body ? JSON.parse(req.body) : null;
+        }
+        if (Buffer.isBuffer(req.body)) {
+            const raw = req.body.toString("utf-8");
+            return raw ? JSON.parse(raw) : null;
+        }
+        if (typeof req.body === "object") {
+            return req.body;
+        }
+    }
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    const buffer = Buffer.concat(chunks);
+    if (!buffer.length) {
+        return null;
+    }
+    const raw = buffer.toString("utf-8");
+    return raw ? JSON.parse(raw) : null;
+};
+const sendJson = (res, statusCode, payload) => {
+    if (typeof res.status === "function") {
+        res.status(statusCode);
+    }
+    else {
+        res.statusCode = statusCode;
+    }
+    res.setHeader("Content-Type", "application/json");
+    if (typeof res.json === "function") {
+        res.json(payload);
+    }
+    else {
+        res.end(JSON.stringify(payload));
+    }
+};
+const withTimeout = async (operation, timeoutMs, timeoutMessage) => {
+    let timer = null;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    reject(new Error(timeoutMessage));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== null) {
+            clearTimeout(timer);
+        }
+    }
+};
+function validateRequest(payload) {
+    if (!payload || typeof payload !== "object") {
+        throw new Error("Invalid payload: expected JSON object");
+    }
+    const { vector, credentials, params } = payload;
+    if (!Array.isArray(vector) || vector.length === 0) {
+        throw new Error("Invalid payload: 'vector' must be a non-empty array");
+    }
+    if (!credentials || typeof credentials !== "object") {
+        throw new Error("Invalid payload: 'credentials' is required");
+    }
+    if (!params || typeof params !== "object") {
+        throw new Error("Invalid payload: 'params' is required");
+    }
+    if (!credentials.node || !credentials.username || !credentials.password) {
+        throw new Error("Invalid credentials: 'node', 'username', and 'password' are required");
+    }
+    if (!params.index || !params.vectorField) {
+        throw new Error("Invalid params: 'index' and 'vectorField' are required");
+    }
+}
+const buildSearchBody = (payload) => {
+    const queryText = payload.queryText || payload.params.queryText;
+    const vectorField = payload.params.vectorField;
+    const size = payload.params.size;
+    if (queryText && queryText.trim()) {
+        return {
+            size: size,
+            query: {
+                bool: {
+                    should: [
+                        {
+                            knn: {
+                                [vectorField]: {
+                                    vector: payload.vector,
+                                    k: size,
+                                },
+                            },
+                        },
+                        {
+                            multi_match: {
+                                query: queryText,
+                                fields: [
+                                    "metadata.scheme_name^5",
+                                    "metadata.scheme_short_name^4",
+                                    "metadata.tags^3",
+                                    "metadata.category^2",
+                                    "text^1",
+                                ],
+                                type: "best_fields",
+                                fuzziness: "AUTO",
+                            },
+                        },
+                        {
+                            term: {
+                                "metadata.content_type.keyword": {
+                                    value: "Scheme Description",
+                                    boost: 2.0,
+                                },
+                            },
+                        },
+                        {
+                            term: {
+                                "metadata.content_type.keyword": {
+                                    value: "Scheme Overview",
+                                    boost: 1.8,
+                                },
+                            },
+                        },
+                        {
+                            term: {
+                                "metadata.content_type.keyword": {
+                                    value: "Benefits",
+                                    boost: 1.5,
+                                },
+                            },
+                        },
+                    ],
+                    must_not: [],
+                },
+            },
+            _source: payload.params.sourceFields ?? true,
+        };
+    }
+    return {
+        size: size,
+        query: {
+            knn: {
+                [vectorField]: {
+                    vector: payload.vector,
+                    k: size,
+                },
+            },
+        },
+        _source: payload.params.sourceFields ?? true,
+    };
+};
+const mapHits = (response) => {
+    const hits = response?.body?.hits?.hits ??
+        response?.hits?.hits ??
+        [];
+    if (!Array.isArray(hits)) {
+        return [];
+    }
+    return hits.map((hit) => ({
+        id: typeof hit._id === "string" ? hit._id : "",
+        score: typeof hit._score === "number" ? hit._score : 0,
+        source: hit._source ?? {},
+    }));
+};
+export const DEFAULT_OPENSEARCH_PROXY_PATH = DEFAULT_VECTOR_SEARCH_API_PATH;
+export const createOpenSearchProxyHandler = (options = {}) => {
+    const logger = options.logger ?? defaultLogger;
+    const cacheClients = options.cacheClients !== false;
+    const requestTimeoutMs = normalizeRequestTimeoutMs(options.requestTimeoutMs);
+    return async (req, res) => {
+        try {
+            if (!req.method || req.method.toUpperCase() !== "POST") {
+                res.setHeader("Allow", "POST");
+                sendJson(res, 405, { error: "Method not allowed" });
+                return;
+            }
+            if (options.allowedOrigins && options.allowedOrigins.length > 0) {
+                const originHeader = req.headers?.origin || "";
+                if (originHeader && !options.allowedOrigins.includes(originHeader)) {
+                    sendJson(res, 403, { error: "Origin not allowed" });
+                    return;
+                }
+            }
+            const payload = (await parseJsonBody(req));
+            validateRequest(payload);
+            const client = getCachedClient(payload.credentials, requestTimeoutMs, cacheClients);
+            const searchBody = buildSearchBody(payload);
+            const response = await withTimeout(client.search({
+                index: payload.params.index,
+                body: searchBody,
+            }), requestTimeoutMs, `OpenSearch request timed out after ${requestTimeoutMs}ms`);
+            const hits = mapHits(response);
+            sendJson(res, 200, { hits });
+        }
+        catch (error) {
+            const errorMessage = error.message;
+            const isTimeout = /timed out/i.test(errorMessage);
+            logger.error("OpenSearch proxy request failed", {
+                message: errorMessage,
+                timeout: isTimeout,
+            });
+            const statusCode = error instanceof SyntaxError || /invalid payload/i.test(error.message)
+                ? 400
+                : isTimeout
+                    ? 504
+                    : 500;
+            sendJson(res, statusCode, {
+                error: statusCode === 400 || statusCode === 504
+                    ? errorMessage
+                    : "OpenSearch proxy error",
+            });
+        }
+    };
+};

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

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

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

@@ -0,0 +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"}

package/dist/services/azure-speech.js

@@ -0,0 +1,33 @@
+export class AzureSpeechService {
+    constructor(config) {
+        this.subscriptionKey = config.subscriptionKey;
+        this.region = config.region;
+    }
+    async fetchToken() {
+        const url = `https://${this.region}.api.cognitive.microsoft.com/sts/v1.0/issueToken`;
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Ocp-Apim-Subscription-Key": this.subscriptionKey,
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch token: ${response.status} ${response.statusText}`);
+            }
+            const token = await response.text();
+            return {
+                token,
+                region: this.region,
+            };
+        }
+        catch (error) {
+            console.error("Failed to fetch Azure speech token:", error);
+            throw error;
+        }
+    }
+    static create(config) {
+        return new AzureSpeechService(config);
+    }
+}

package/dist/services/bedrock.d.ts

@@ -0,0 +1,18 @@
+import type { AgentActionResponse } from "../types.js";
+export interface BedrockConfig {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    modelId: string;
+    embeddingModelId?: string | null;
+}
+export declare class BedrockService {
+    private client;
+    private actionModelId;
+    private embeddingModelId;
+    constructor(config: BedrockConfig);
+    extractAction(userInput: string): Promise<AgentActionResponse>;
+    static create(config: BedrockConfig): BedrockService;
+    embedText(text: string): Promise<number[]>;
+}
+//# sourceMappingURL=bedrock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../src/services/bedrock.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAmB,MAAM,aAAa,CAAC;AAExE,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;AAmBD,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAAgB;gBAE5B,MAAM,EAAE,aAAa;IAuB3B,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAiEpE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc;IAO9C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAyDjD"}

package/dist/services/bedrock.js

@@ -0,0 +1,132 @@
+import { BedrockRuntimeClient, InvokeModelCommand, } from "@aws-sdk/client-bedrock-runtime";
+const SYSTEM_PROMPT = `You are an action extraction assistant.
+
+VERY IMPORTANT INSTRUCTIONS:
+- RESPOND ONLY IN THE SPECIFIED JSON FORMAT.
+- ALWAYS RETURN A SINGLE JSON OBJECT.
+- IF THE USER INPUT DOES NOT CLEARLY INDICATE AN ACTION, RESPOND WITH {"action": "unknown"}.
+- DO NOT RESPOND WITH ANYTHING OTHER THAN THE JSON OBJECT.
+- CHOOSE THE MOST SPECIFIC ACTION FROM THE ALLOWED LIST. IF MULTIPLE ACTIONS APPLY, CHOOSE THE ONE THAT BEST MATCHES THE USER REQUEST.
+- DO NOT INVENT YOUR OWN ACTION. IT MUST BE ONE OF THE GIVEN ACTIONS OR "unknown".
+- WHEN THE USER CLEARLY EXPRESSES A DESIRE TO SEARCH OR FIND INFORMATION, RESPOND WITH {"action": "search_content", "query": "concise keywords"}.
+- WHEN YOU RETURN THE "search_content" ACTION, THE "query" FIELD MUST BE A SHORT PHRASE CAPTURING THE USER'S INTENT WITHOUT FILLER WORDS.
+
+The only possible actions are:
+"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", "navigate_home", "search_content", "navigate_search", "navigate_faqs", "navigate_help", "navigate_contact", "navigate_about", "navigate_screen_reader", "navigate_accessibility", "navigate_disclaimer", "navigate_terms_conditions", "stop".`;
+const DEFAULT_EMBEDDING_MODEL_ID = "cohere.embed-multilingual-v3";
+export class BedrockService {
+    constructor(config) {
+        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;
+        }
+    }
+    async extractAction(userInput) {
+        const body = {
+            anthropic_version: "bedrock-2023-05-31",
+            max_tokens: 70,
+            system: SYSTEM_PROMPT,
+            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 input = {
+            modelId: this.actionModelId,
+            contentType: "application/json",
+            accept: "application/json",
+            body: JSON.stringify(body),
+        };
+        try {
+            const command = new InvokeModelCommand(input);
+            const response = await this.client.send(command);
+            if (!response.body) {
+                throw new Error("No response body from Bedrock");
+            }
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+            let rawText = "";
+            if (responseBody.content && responseBody.content.length > 0) {
+                rawText = responseBody.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 API error:", error);
+            throw error;
+        }
+    }
+    static create(config) {
+        return new BedrockService(config);
+    }
+    async embedText(text) {
+        const prompt = text.trim();
+        if (!prompt) {
+            return [];
+        }
+        if (!this.embeddingModelId) {
+            throw new Error("Bedrock embedding model is not configured");
+        }
+        const payload = {
+            inputText: prompt,
+        };
+        const input = {
+            modelId: this.embeddingModelId,
+            contentType: "application/json",
+            accept: "application/json",
+            body: JSON.stringify(payload),
+        };
+        try {
+            const command = new InvokeModelCommand(input);
+            const response = await this.client.send(command);
+            if (!response.body) {
+                throw new Error("No response body from Bedrock embedding request");
+            }
+            const decoded = JSON.parse(new TextDecoder().decode(response.body));
+            const embedding = decoded.embedding ||
+                decoded.vector ||
+                (Array.isArray(decoded.embeddings)
+                    ? decoded.embeddings
+                    : decoded.embeddings?.values) ||
+                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("Bedrock embedding error:", error);
+            throw error;
+        }
+    }
+}

package/dist/services/schemes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemes.d.ts","sourceRoot":"","sources":["../../src/services/schemes.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC"}

package/dist/services/schemes.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import type { OpenSearchConfig } from "../types.js";
+export interface VectorSearchHit {
+    id: string;
+    score: number;
+    source: Record<string, unknown>;
+}
+export declare class VectorSearchService {
+    private readonly config;
+    private readonly endpoint;
+    constructor(config: OpenSearchConfig);
+    search(vector: number[], queryText?: string): Promise<VectorSearchHit[]>;
+    getSourceUrl(hit: VectorSearchHit): string | null;
+    findBestMatchWithUrl(hits: VectorSearchHit[]): {
+        hit: VectorSearchHit;
+        url: string;
+    } | null;
+    private buildRequestPayload;
+    private resolveEndpoint;
+    private safeReadText;
+}
+//# sourceMappingURL=vector-search.d.ts.map

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

@@ -0,0 +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"}