@myscheme/voice-navigation-sdk 0.1.3 → 0.1.6

package/dist/server/bedrock-handler.js

@@ -0,0 +1,114 @@
+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;
+}
+export async function bedrockHandler(req, res) {
+    if (req.method !== "POST") {
+        res.setHeader("Allow", ["POST"]);
+        res.status(405).json({ error: "Method not allowed" });
+        return;
+    }
+    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");
+        res.status(500).json({
+            error: "Missing AWS credentials",
+            hint: "Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables",
+        });
+        return;
+    }
+    const requestBody = req.body?.body;
+    if (!requestBody) {
+        res.status(400).json({ error: "Missing request body" });
+        return;
+    }
+    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);
+            res.status(response.status).json({
+                error: "Bedrock API error",
+                details: errorText,
+            });
+            return;
+        }
+        const json = await response.json();
+        res.status(200).json(json);
+    }
+    catch (error) {
+        console.error("[VoiceNavigation] Bedrock action extraction error:", error);
+        res.status(500).json({
+            error: "Failed to extract action",
+            message: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+}

package/dist/server/index.d.ts

@@ -1,3 +1,7 @@
+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 { 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":"AAoBA,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,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,5 @@
+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 { 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"}

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