@aiwerk/mcp-bridge 1.3.0 → 1.5.0

package/dist/src/embeddings.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from "./types.js";
+export interface EmbeddingProvider {
+    embed(texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+}
+export declare class GeminiEmbedding implements EmbeddingProvider {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    embed(texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+}
+export declare class OpenAIEmbedding implements EmbeddingProvider {
+    private readonly apiKey;
+    private readonly model;
+    constructor(apiKey: string, model?: string);
+    embed(texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+}
+export declare class OllamaEmbedding implements EmbeddingProvider {
+    private readonly model;
+    private readonly baseUrl;
+    constructor(model?: string, baseUrl?: string);
+    embed(texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+}
+export declare class KeywordEmbedding implements EmbeddingProvider {
+    private vocabulary;
+    private vocabSize;
+    embed(texts: string[]): Promise<number[][]>;
+    dimensions(): number;
+    private tokenize;
+}
+export declare function createEmbeddingProvider(type: "auto" | "gemini" | "openai" | "ollama" | "keyword", config?: {
+    model?: string;
+    apiKey?: string;
+    ollamaUrl?: string;
+}, logger?: Logger): EmbeddingProvider;

package/dist/src/embeddings.js

@@ -0,0 +1,176 @@
+export class GeminiEmbedding {
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async embed(texts) {
+        const results = [];
+        for (const text of texts) {
+            const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent?key=${this.apiKey}`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    content: { parts: [{ text }] }
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            results.push(data.embedding.values);
+        }
+        return results;
+    }
+    dimensions() {
+        return 768;
+    }
+}
+export class OpenAIEmbedding {
+    apiKey;
+    model;
+    constructor(apiKey, model = "text-embedding-3-small") {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async embed(texts) {
+        const response = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({ input: texts, model: this.model })
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.data
+            .sort((a, b) => a.index - b.index)
+            .map((item) => item.embedding);
+    }
+    dimensions() {
+        return 1536;
+    }
+}
+export class OllamaEmbedding {
+    model;
+    baseUrl;
+    constructor(model = "nomic-embed-text", baseUrl = "http://localhost:11434") {
+        this.model = model;
+        this.baseUrl = baseUrl;
+    }
+    async embed(texts) {
+        const response = await fetch(`${this.baseUrl}/api/embed`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: this.model, input: texts })
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.embeddings;
+    }
+    dimensions() {
+        return 768;
+    }
+}
+export class KeywordEmbedding {
+    vocabulary = new Map();
+    vocabSize = 0;
+    async embed(texts) {
+        // Build vocabulary from all texts
+        this.vocabulary.clear();
+        this.vocabSize = 0;
+        const tokenizedTexts = texts.map((text) => this.tokenize(text));
+        for (const tokens of tokenizedTexts) {
+            for (const token of tokens) {
+                if (!this.vocabulary.has(token)) {
+                    this.vocabulary.set(token, this.vocabSize++);
+                }
+            }
+        }
+        if (this.vocabSize === 0) {
+            return texts.map(() => [0]);
+        }
+        // Create TF vectors
+        const vectors = [];
+        for (const tokens of tokenizedTexts) {
+            const vector = new Array(this.vocabSize).fill(0);
+            for (const token of tokens) {
+                const idx = this.vocabulary.get(token);
+                vector[idx] += 1;
+            }
+            // Normalize by document length
+            const len = tokens.length || 1;
+            for (let i = 0; i < vector.length; i++) {
+                vector[i] /= len;
+            }
+            vectors.push(vector);
+        }
+        // Apply IDF weighting
+        const docCount = texts.length;
+        const idf = new Array(this.vocabSize).fill(0);
+        for (let i = 0; i < this.vocabSize; i++) {
+            let df = 0;
+            for (const vec of vectors) {
+                if (vec[i] > 0)
+                    df++;
+            }
+            idf[i] = Math.log((docCount + 1) / (df + 1)) + 1;
+        }
+        for (const vec of vectors) {
+            for (let i = 0; i < vec.length; i++) {
+                vec[i] *= idf[i];
+            }
+        }
+        return vectors;
+    }
+    dimensions() {
+        return this.vocabSize || 1;
+    }
+    tokenize(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, " ")
+            .split(/\s+/)
+            .filter((t) => t.length > 1);
+    }
+}
+export function createEmbeddingProvider(type, config, logger) {
+    if (type === "gemini") {
+        const key = config?.apiKey || process.env.GEMINI_API_KEY;
+        if (!key)
+            throw new Error("GEMINI_API_KEY is required for gemini embedding provider");
+        return new GeminiEmbedding(key);
+    }
+    if (type === "openai") {
+        const key = config?.apiKey || process.env.OPENAI_API_KEY;
+        if (!key)
+            throw new Error("OPENAI_API_KEY is required for openai embedding provider");
+        return new OpenAIEmbedding(key, config?.model);
+    }
+    if (type === "ollama") {
+        return new OllamaEmbedding(config?.model, config?.ollamaUrl);
+    }
+    if (type === "keyword") {
+        return new KeywordEmbedding();
+    }
+    // auto: try gemini, openai, ollama, then keyword fallback
+    const geminiKey = config?.apiKey || process.env.GEMINI_API_KEY;
+    if (geminiKey) {
+        logger?.debug("[mcp-bridge] Intent routing: using Gemini embeddings");
+        return new GeminiEmbedding(geminiKey);
+    }
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+        logger?.debug("[mcp-bridge] Intent routing: using OpenAI embeddings");
+        return new OpenAIEmbedding(openaiKey, config?.model);
+    }
+    // For ollama, we can't synchronously check reachability in factory,
+    // so we skip it in auto mode and fall back to keyword.
+    // Users who want ollama should specify type="ollama" explicitly.
+    logger?.debug("[mcp-bridge] Intent routing: using keyword fallback embeddings");
+    return new KeywordEmbedding();
+}

package/dist/src/intent-router.d.ts

@@ -0,0 +1,25 @@
+import type { EmbeddingProvider } from "./embeddings.js";
+import type { Logger } from "./types.js";
+import type { McpTool } from "./types.js";
+export interface IntentMatch {
+    server: string;
+    tool: string;
+    score: number;
+    alternatives: Array<{
+        server: string;
+        tool: string;
+        score: number;
+    }>;
+}
+export declare class IntentRouter {
+    private readonly embeddingProvider;
+    private readonly logger;
+    private readonly store;
+    private indexed;
+    private minScore;
+    constructor(embeddingProvider: EmbeddingProvider, logger: Logger, minScore?: number);
+    indexTools(servers: Record<string, McpTool[]>): Promise<void>;
+    resolve(intent: string): Promise<IntentMatch | null>;
+    isIndexed(): boolean;
+    clearIndex(): void;
+}

package/dist/src/intent-router.js

@@ -0,0 +1,80 @@
+import { VectorStore } from "./vector-store.js";
+const DEFAULT_MIN_SCORE = 0.3;
+const DEFAULT_TOP_K = 4;
+export class IntentRouter {
+    embeddingProvider;
+    logger;
+    store = new VectorStore();
+    indexed = false;
+    minScore;
+    constructor(embeddingProvider, logger, minScore) {
+        this.embeddingProvider = embeddingProvider;
+        this.logger = logger;
+        this.minScore = minScore ?? DEFAULT_MIN_SCORE;
+    }
+    async indexTools(servers) {
+        this.store.clear();
+        this.indexed = false;
+        const entries = [];
+        for (const [serverName, tools] of Object.entries(servers)) {
+            for (const tool of tools) {
+                const text = `${tool.name}: ${tool.description || ""}`;
+                entries.push({
+                    id: `${serverName}/${tool.name}`,
+                    text,
+                    server: serverName,
+                    tool: tool.name
+                });
+            }
+        }
+        if (entries.length === 0) {
+            this.indexed = true;
+            return;
+        }
+        const texts = entries.map((e) => e.text);
+        const vectors = await this.embeddingProvider.embed(texts);
+        for (let i = 0; i < entries.length; i++) {
+            this.store.add(entries[i].id, vectors[i], {
+                server: entries[i].server,
+                tool: entries[i].tool,
+                description: entries[i].text
+            });
+        }
+        this.indexed = true;
+        this.logger.debug(`[mcp-bridge] Intent router indexed ${entries.length} tools`);
+    }
+    async resolve(intent) {
+        if (!this.indexed || this.store.size() === 0) {
+            return null;
+        }
+        // Embed the intent together with stored texts for keyword provider compatibility
+        // For API-based providers this is just a single text embedding
+        const [queryVector] = await this.embeddingProvider.embed([intent]);
+        const results = this.store.search(queryVector, DEFAULT_TOP_K);
+        if (results.length === 0) {
+            return null;
+        }
+        const best = results[0];
+        if (best.score < this.minScore) {
+            this.logger.debug(`[mcp-bridge] Intent "${intent}" best match score ${best.score.toFixed(3)} below threshold ${this.minScore}`);
+            return null;
+        }
+        return {
+            server: best.metadata.server,
+            tool: best.metadata.tool,
+            score: best.score,
+            alternatives: results.slice(1).map((r) => ({
+                server: r.metadata.server,
+                tool: r.metadata.tool,
+                score: r.score
+            }))
+        };
+    }
+    isIndexed() {
+        return this.indexed;
+    }
+    clearIndex() {
+        this.store.clear();
+        this.indexed = false;
+    }
+}

package/dist/src/mcp-router.d.ts

@@ -35,6 +35,19 @@ export type RouterDispatchResponse = {
 } | {
     action: "status";
     servers: RouterServerStatus[];
+} | {
+    action: "intent";
+    intent: string;
+    match: {
+        server: string;
+        tool: string;
+        score: number;
+    };
+    alternatives: Array<{
+        server: string;
+        tool: string;
+        score: number;
+    }>;
 } | {
     error: RouterErrorCode;
     message: string;
@@ -54,10 +67,12 @@ export declare class McpRouter {
     private readonly idleTimeoutMs;
     private readonly maxConcurrent;
     private readonly states;
+    private intentRouter;
     constructor(servers: Record<string, McpServerConfig>, clientConfig: McpClientConfig, logger: Logger, transportRefs?: Partial<RouterTransportRefs>);
     static generateDescription(servers: Record<string, McpServerConfig>): string;
     dispatch(server?: string, action?: string, tool?: string, params?: any): Promise<RouterDispatchResponse>;
     getToolList(server: string): Promise<RouterToolHint[]>;
+    private resolveIntent;
     private getStatus;
     disconnectAll(): Promise<void>;
     private ensureConnected;

package/dist/src/mcp-router.js

@@ -3,6 +3,9 @@ import { StdioTransport } from "./transport-stdio.js";
 import { StreamableHttpTransport } from "./transport-streamable-http.js";
 import { fetchToolsList, initializeProtocol, PACKAGE_VERSION } from "./protocol.js";
 import { compressDescription } from "./schema-compression.js";
+import { IntentRouter } from "./intent-router.js";
+import { createEmbeddingProvider } from "./embeddings.js";
+import { isToolAllowed, processResult } from "./security.js";
 const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_MAX_CONCURRENT = 5;
 export class McpRouter {
@@ -13,6 +16,7 @@ export class McpRouter {
     idleTimeoutMs;
     maxConcurrent;
     states = new Map();
+    intentRouter = null;
     constructor(servers, clientConfig, logger, transportRefs) {
         this.servers = servers;
         this.clientConfig = clientConfig;
@@ -45,6 +49,14 @@ export class McpRouter {
             if (normalizedAction === "status") {
                 return this.getStatus();
             }
+            // Intent action: find server+tool from natural language
+            if (normalizedAction === "intent") {
+                const intent = params?.intent || tool;
+                if (!intent) {
+                    return this.error("invalid_params", "intent string is required for action=intent");
+                }
+                return this.resolveIntent(intent);
+            }
             if (!server) {
                 return this.error("invalid_params", "server is required");
             }
@@ -83,6 +95,10 @@ export class McpRouter {
                     state.toolsCache = undefined;
                     state.fullToolsMap = undefined;
                     state.toolNames = [];
+                    // Clear intent index so it re-indexes on next intent query
+                    if (this.intentRouter) {
+                        this.intentRouter.clearIndex();
+                    }
                     const tools = await this.getToolList(server);
                     return { server, action: "refresh", refreshed: true, tools };
                 }
@@ -91,7 +107,7 @@ export class McpRouter {
                 }
             }
             if (normalizedAction !== "call") {
-                return this.error("invalid_params", `action must be one of: list, call, refresh, schema`);
+                return this.error("invalid_params", `action must be one of: list, call, refresh, schema, intent`);
             }
             if (!tool) {
                 return this.error("invalid_params", "tool is required for action=call");
@@ -106,6 +122,11 @@ export class McpRouter {
             if (!state.toolNames.includes(tool)) {
                 return this.error("unknown_tool", `Tool '${tool}' not found on server '${server}'`, state.toolNames);
             }
+            // Defense in depth: double-check tool filter
+            const serverConfig = this.servers[server];
+            if (!isToolAllowed(tool, serverConfig)) {
+                return this.error("unknown_tool", `Tool '${tool}' is not allowed on server '${server}'`, state.toolNames);
+            }
             this.markUsed(server);
             const response = await state.transport.sendRequest({
                 jsonrpc: "2.0",
@@ -118,7 +139,9 @@ export class McpRouter {
             if (response.error) {
                 return this.error("mcp_error", response.error.message, undefined, response.error.code);
             }
-            return { server, action: "call", tool, result: response.result };
+            // Security pipeline: truncate → sanitize → trust-tag
+            const result = processResult(response.result, server, serverConfig, this.clientConfig);
+            return { server, action: "call", tool, result };
         }
         catch (error) {
             return this.error("mcp_error", error instanceof Error ? error.message : String(error));
@@ -133,7 +156,9 @@ export class McpRouter {
             this.markUsed(server);
             return state.toolsCache;
         }
-        const tools = await fetchToolsList(state.transport);
+        const allTools = await fetchToolsList(state.transport);
+        const serverConfig = this.servers[server];
+        const tools = allTools.filter((tool) => isToolAllowed(tool.name, serverConfig));
         state.toolNames = tools.map((tool) => tool.name);
         // Store full tool metadata for action=schema
         state.fullToolsMap = new Map(tools.map((tool) => [tool.name, { description: tool.description || "", inputSchema: tool.inputSchema }]));
@@ -149,6 +174,51 @@ export class McpRouter {
         this.markUsed(server);
         return state.toolsCache;
     }
+    async resolveIntent(intent) {
+        try {
+            // Lazily create the intent router
+            if (!this.intentRouter) {
+                const routingConfig = this.clientConfig.intentRouting;
+                const embeddingType = routingConfig?.embedding ?? "auto";
+                const provider = createEmbeddingProvider(embeddingType, { model: routingConfig?.model }, this.logger);
+                this.intentRouter = new IntentRouter(provider, this.logger, routingConfig?.minScore);
+            }
+            // Index tools if not already done
+            if (!this.intentRouter.isIndexed()) {
+                const allTools = {};
+                for (const serverName of Object.keys(this.servers)) {
+                    try {
+                        await this.getToolList(serverName);
+                        const state = this.states.get(serverName);
+                        if (state?.fullToolsMap) {
+                            allTools[serverName] = [...state.fullToolsMap.entries()].map(([name, meta]) => ({
+                                name,
+                                description: meta.description,
+                                inputSchema: meta.inputSchema
+                            }));
+                        }
+                    }
+                    catch (err) {
+                        this.logger.warn(`[mcp-bridge] Intent routing: failed to index tools from ${serverName}:`, err);
+                    }
+                }
+                await this.intentRouter.indexTools(allTools);
+            }
+            const match = await this.intentRouter.resolve(intent);
+            if (!match) {
+                return this.error("invalid_params", `No tool found matching intent: "${intent}"`);
+            }
+            return {
+                action: "intent",
+                intent,
+                match: { server: match.server, tool: match.tool, score: match.score },
+                alternatives: match.alternatives
+            };
+        }
+        catch (err) {
+            return this.error("mcp_error", `Intent resolution failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     getStatus() {
         const serverStatuses = Object.entries(this.servers).map(([name, config]) => {
             const state = this.states.get(name);

package/dist/src/security.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Security processing for MCP tool results.
+ *
+ * Pipeline order: truncate → sanitize → trust-tag
+ */
+import type { McpServerConfig, McpClientConfig } from "./types.js";
+/**
+ * Sanitize a tool result by stripping HTML and prompt injection patterns.
+ */
+export declare function sanitizeResult(result: any): any;
+/**
+ * Check if a tool is allowed by the server's toolFilter config.
+ * Returns true if the tool should be visible/callable.
+ */
+export declare function isToolAllowed(toolName: string, serverConfig: McpServerConfig): boolean;
+/**
+ * Apply max result size truncation.
+ * Returns the result as-is or a truncation wrapper.
+ */
+export declare function applyMaxResultSize(result: any, serverConfig: McpServerConfig, clientConfig: McpClientConfig): any;
+/**
+ * Apply trust level wrapping/sanitization.
+ */
+export declare function applyTrustLevel(result: any, serverName: string, serverConfig: McpServerConfig): any;
+/**
+ * Full security pipeline: truncate → sanitize → trust-tag
+ */
+export declare function processResult(result: any, serverName: string, serverConfig: McpServerConfig, clientConfig: McpClientConfig): any;

package/dist/src/security.js

@@ -0,0 +1,127 @@
+/**
+ * Security processing for MCP tool results.
+ *
+ * Pipeline order: truncate → sanitize → trust-tag
+ */
+// Prompt injection patterns to strip (case-insensitive)
+const INJECTION_PATTERNS = [
+    /ignore\s+(all\s+)?previous\s+instructions/gi,
+    /ignore\s+(all\s+)?prior\s+instructions/gi,
+    /disregard\s+(all\s+)?previous\s+instructions/gi,
+    /you\s+are\s+now\b/gi,
+    /^system\s*:/gim,
+    /\bact\s+as\s+(a|an)\s+/gi,
+    /pretend\s+you\s+are\b/gi,
+    /from\s+now\s+on\s+you\s+are\b/gi,
+    /new\s+instructions\s*:/gi,
+    /override\s+(all\s+)?instructions/gi,
+];
+function stripHtmlTags(text) {
+    return text.replace(/<[^>]*>/g, "");
+}
+function stripInjectionPatterns(text) {
+    let result = text;
+    for (const pattern of INJECTION_PATTERNS) {
+        // Reset lastIndex for global regexes
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, "");
+    }
+    return result;
+}
+function sanitizeString(text) {
+    return stripInjectionPatterns(stripHtmlTags(text));
+}
+/**
+ * Sanitize a tool result by stripping HTML and prompt injection patterns.
+ */
+export function sanitizeResult(result) {
+    if (typeof result === "string") {
+        return sanitizeString(result);
+    }
+    if (Array.isArray(result)) {
+        return result.map((item) => sanitizeResult(item));
+    }
+    if (result !== null && typeof result === "object") {
+        // MCP standard content array
+        if (Array.isArray(result.content)) {
+            return {
+                ...result,
+                content: result.content.map((item) => {
+                    if (item.type === "text" && typeof item.text === "string") {
+                        return { ...item, text: sanitizeString(item.text) };
+                    }
+                    return item;
+                }),
+            };
+        }
+        // Recursively sanitize object values
+        const sanitized = {};
+        for (const [key, value] of Object.entries(result)) {
+            sanitized[key] = sanitizeResult(value);
+        }
+        return sanitized;
+    }
+    return result;
+}
+/**
+ * Check if a tool is allowed by the server's toolFilter config.
+ * Returns true if the tool should be visible/callable.
+ */
+export function isToolAllowed(toolName, serverConfig) {
+    const filter = serverConfig.toolFilter;
+    if (!filter)
+        return true;
+    const { allow, deny } = filter;
+    if (allow && allow.length > 0) {
+        // Whitelist mode: only allowed tools, minus denied
+        if (!allow.includes(toolName))
+            return false;
+    }
+    if (deny && deny.length > 0) {
+        if (deny.includes(toolName))
+            return false;
+    }
+    return true;
+}
+/**
+ * Apply max result size truncation.
+ * Returns the result as-is or a truncation wrapper.
+ */
+export function applyMaxResultSize(result, serverConfig, clientConfig) {
+    const limit = serverConfig.maxResultChars ?? clientConfig.maxResultChars;
+    if (limit === undefined)
+        return result;
+    const serialized = JSON.stringify(result);
+    if (serialized.length <= limit)
+        return result;
+    return {
+        _truncated: true,
+        _originalLength: serialized.length,
+        result: serialized.slice(0, limit),
+    };
+}
+/**
+ * Apply trust level wrapping/sanitization.
+ */
+export function applyTrustLevel(result, serverName, serverConfig) {
+    const trust = serverConfig.trust ?? "trusted";
+    switch (trust) {
+        case "trusted":
+            return result;
+        case "untrusted":
+            return { _trust: "untrusted", _server: serverName, result };
+        case "sanitize":
+            return sanitizeResult(result);
+        default:
+            return result;
+    }
+}
+/**
+ * Full security pipeline: truncate → sanitize → trust-tag
+ */
+export function processResult(result, serverName, serverConfig, clientConfig) {
+    let processed = applyMaxResultSize(result, serverConfig, clientConfig);
+    // Sanitize step (only for trust=sanitize, handled inside applyTrustLevel)
+    processed = applyTrustLevel(processed, serverName, serverConfig);
+    return processed;
+}

package/dist/src/types.d.ts

@@ -14,6 +14,12 @@ export interface McpServerConfig {
     args?: string[];
     env?: Record<string, string>;
     framing?: "auto" | "lsp" | "newline";
+    trust?: "trusted" | "untrusted" | "sanitize";
+    toolFilter?: {
+        deny?: string[];
+        allow?: string[];
+    };
+    maxResultChars?: number;
 }
 export interface McpClientConfig {
     servers: Record<string, McpServerConfig>;
@@ -28,6 +34,12 @@ export interface McpClientConfig {
         enabled?: boolean;
         maxDescriptionLength?: number;
     };
+    intentRouting?: {
+        embedding?: "auto" | "gemini" | "openai" | "ollama" | "keyword";
+        model?: string;
+        minScore?: number;
+    };
+    maxResultChars?: number;
 }
 export interface McpTool {
     name: string;

package/dist/src/vector-store.d.ts

@@ -0,0 +1,17 @@
+export interface VectorMetadata {
+    server: string;
+    tool: string;
+    description: string;
+}
+export declare class VectorStore {
+    private entries;
+    add(id: string, vector: number[], metadata: VectorMetadata): void;
+    search(queryVector: number[], topK: number): Array<{
+        id: string;
+        score: number;
+        metadata: VectorMetadata;
+    }>;
+    clear(): void;
+    size(): number;
+}
+export declare function cosineSimilarity(a: number[], b: number[]): number;

package/dist/src/vector-store.js

@@ -0,0 +1,43 @@
+export class VectorStore {
+    entries = [];
+    add(id, vector, metadata) {
+        this.entries.push({ id, vector, metadata });
+    }
+    search(queryVector, topK) {
+        const scored = this.entries.map((entry) => ({
+            id: entry.id,
+            score: cosineSimilarity(queryVector, entry.vector),
+            metadata: entry.metadata
+        }));
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
+    clear() {
+        this.entries = [];
+    }
+    size() {
+        return this.entries.length;
+    }
+}
+export function cosineSimilarity(a, b) {
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < len; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    // Handle any extra dimensions (vectors may differ in length for keyword embeddings)
+    for (let i = len; i < a.length; i++) {
+        normA += a[i] * a[i];
+    }
+    for (let i = len; i < b.length; i++) {
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denom === 0)
+        return 0;
+    return dot / denom;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwerk/mcp-bridge",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Standalone MCP server that multiplexes multiple MCP servers into one interface",
   "type": "module",
   "main": "./dist/src/index.js",