@stabgan/openrouter-mcp-multimodal 1.4.0 → 1.8.0

package/dist/__tests__/model-cache.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { ModelCache } from '../model-cache.js';
+describe('ModelCache', () => {
+    let cache;
+    beforeEach(() => {
+        vi.unstubAllEnvs();
+        cache = ModelCache.getInstance();
+        cache.setModels([]);
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+    const sampleModels = [
+        {
+            id: 'openai/gpt-4',
+            name: 'OpenAI: GPT-4',
+            architecture: { input_modalities: ['text', 'image'] },
+            context_length: 128000,
+        },
+        {
+            id: 'anthropic/claude-3',
+            name: 'Anthropic: Claude 3',
+            architecture: { input_modalities: ['text', 'image'] },
+            context_length: 200000,
+        },
+        {
+            id: 'meta/llama-3',
+            name: 'Meta: Llama 3',
+            architecture: { input_modalities: ['text'] },
+            context_length: 8192,
+        },
+        {
+            id: 'qwen/qwen-vl:free',
+            name: 'Qwen: VL (free)',
+            architecture: { input_modalities: ['text', 'image'] },
+            context_length: 32000,
+        },
+    ];
+    it('should be a singleton', () => {
+        const a = ModelCache.getInstance();
+        const b = ModelCache.getInstance();
+        expect(a).toBe(b);
+    });
+    it('should store and retrieve models', () => {
+        cache.setModels(sampleModels);
+        expect(cache.getAll()).toHaveLength(4);
+        expect(cache.get('openai/gpt-4')).toEqual(sampleModels[0]);
+        expect(cache.get('nonexistent')).toBeNull();
+    });
+    it('should check model existence', () => {
+        cache.setModels(sampleModels);
+        expect(cache.has('openai/gpt-4')).toBe(true);
+        expect(cache.has('nonexistent')).toBe(false);
+    });
+    it('should report valid cache after setModels', () => {
+        expect(cache.isValid()).toBe(false);
+        cache.setModels(sampleModels);
+        expect(cache.isValid()).toBe(true);
+    });
+    it('should search by query', () => {
+        cache.setModels(sampleModels);
+        const results = cache.search({ query: 'gpt' });
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe('openai/gpt-4');
+    });
+    it('should search by provider', () => {
+        cache.setModels(sampleModels);
+        const results = cache.search({ provider: 'anthropic' });
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe('anthropic/claude-3');
+    });
+    it('should filter by vision capability', () => {
+        cache.setModels(sampleModels);
+        const results = cache.search({ capabilities: { vision: true } });
+        expect(results).toHaveLength(3);
+        expect(results.every((m) => m.architecture?.input_modalities?.includes('image'))).toBe(true);
+    });
+    it('should respect limit', () => {
+        cache.setModels(sampleModels);
+        const results = cache.search({ limit: 2 });
+        expect(results).toHaveLength(2);
+    });
+    it('should combine filters', () => {
+        cache.setModels(sampleModels);
+        const results = cache.search({ query: 'free', capabilities: { vision: true } });
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe('qwen/qwen-vl:free');
+    });
+    it('should expire cache after TTL from env', async () => {
+        vi.stubEnv('OPENROUTER_MODEL_CACHE_TTL_MS', '25');
+        cache.setModels(sampleModels);
+        expect(cache.isValid()).toBe(true);
+        await new Promise((r) => setTimeout(r, 60));
+        expect(cache.isValid()).toBe(false);
+    });
+});

package/dist/index.js

@@ -1,51 +1,52 @@
 #!/usr/bin/env node
-// OpenRouter Multimodal MCP Server
+import { Readable } from 'node:stream';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ToolHandlers } from './tool-handlers.js';
-// Define the default model to use when none is specified
-const DEFAULT_MODEL = 'qwen/qwen2.5-vl-32b-instruct:free';
-class OpenRouterMultimodalServer {
-    server;
-    toolHandlers; // Using definite assignment assertion
-    constructor() {
-        // Retrieve API key and default model from environment variables
-        const apiKey = process.env.OPENROUTER_API_KEY;
-        const defaultModel = process.env.OPENROUTER_DEFAULT_MODEL || DEFAULT_MODEL;
-        // Check if API key is provided
-        if (!apiKey) {
-            throw new Error('OPENROUTER_API_KEY environment variable is required');
-        }
-        // Initialize the server
-        this.server = new Server({
-            name: 'openrouter-multimodal-server',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        // Set up error handling
-        this.server.onerror = (error) => console.error('[MCP Error]', error);
-        // Initialize tool handlers
-        this.toolHandlers = new ToolHandlers(this.server, apiKey, defaultModel);
-        process.on('SIGINT', async () => {
-            await this.server.close();
-            process.exit(0);
-        });
-    }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error('OpenRouter Multimodal MCP server running on stdio');
-        console.error('Using API key from environment variable');
-        console.error('Note: To use OpenRouter Multimodal, add the API key to your environment variables:');
-        console.error('      OPENROUTER_API_KEY=your-api-key');
-        const modelDisplay = process.env.OPENROUTER_DEFAULT_MODEL || DEFAULT_MODEL;
-        console.error(`      Using default model: ${modelDisplay}`);
-        console.error('Server is ready to process tool calls. Waiting for input...');
-    }
+const DEFAULT_MODEL = 'nvidia/nemotron-nano-12b-v2-vl:free';
+// Exit on fatal errors to prevent silent zombie processes (issue #5)
+process.on('uncaughtException', (err) => {
+    console.error('[Fatal]', err);
+    process.exit(1);
+});
+process.on('unhandledRejection', (err) => {
+    console.error('[Fatal]', err);
+    process.exit(1);
+});
+const apiKey = process.env.OPENROUTER_API_KEY;
+if (!apiKey) {
+    console.error('OPENROUTER_API_KEY is required');
+    process.exit(1);
 }
-const server = new OpenRouterMultimodalServer();
-server.run().catch(console.error);
-//# sourceMappingURL=index.js.map
+const defaultModel = process.env.OPENROUTER_DEFAULT_MODEL || process.env.DEFAULT_MODEL || DEFAULT_MODEL;
+const server = new Server({ name: 'openrouter-multimodal-server', version: '1.8.0' }, { capabilities: { tools: {} } });
+server.onerror = (error) => console.error('[MCP Error]', error);
+new ToolHandlers(server, apiKey, defaultModel);
+process.on('SIGINT', async () => {
+    await server.close();
+    process.exit(0);
+});
+// Ensure stdin emits raw Buffers — some hosts (e.g. Claude Desktop) may set
+// encoding on the stdin pipe, which causes the MCP SDK's ReadBuffer to receive
+// strings instead of Buffers. ReadBuffer.readMessage() calls subarray() which
+// doesn't exist on strings, triggering an infinite error loop.
+const stdinStream = process.stdin;
+stdinStream.setEncoding?.(undefined);
+const safeStdin = new Readable({
+    read() { },
+});
+process.stdin.on('data', (chunk) => {
+    safeStdin.push(typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk);
+});
+process.stdin.on('end', () => safeStdin.push(null));
+process.stdin.on('error', (err) => safeStdin.destroy(err));
+const transport = new StdioServerTransport(safeStdin, process.stdout);
+server
+    .connect(transport)
+    .then(() => {
+    console.error(`OpenRouter MCP server running (model: ${defaultModel})`);
+})
+    .catch((err) => {
+    console.error('[Fatal] Server failed to start:', err);
+    process.exit(1);
+});

package/dist/model-cache.d.ts

@@ -1,56 +1,28 @@
-/**
- * ModelCache - Caches OpenRouter model data to reduce API calls
- */
+export interface OpenRouterModelRecord {
+    id: string;
+    name?: string;
+    architecture?: {
+        input_modalities?: string[];
+    };
+    context_length?: number;
+    [key: string]: unknown;
+}
 export declare class ModelCache {
     private static instance;
     private models;
-    private lastFetchTime;
-    private cacheExpiryTime;
-    private constructor();
-    /**
-     * Get singleton instance
-     */
+    private fetchedAt;
     static getInstance(): ModelCache;
-    /**
-     * Check if the cache is valid
-     */
-    isCacheValid(): boolean;
-    /**
-     * Store all models
-     */
-    setModels(models: any[]): void;
-    /**
-     * Get all cached models
-     */
-    getAllModels(): any[];
-    /**
-     * Get a specific model by ID
-     */
-    getModel(modelId: string): any | null;
-    /**
-     * Check if a model exists
-     */
-    hasModel(modelId: string): boolean;
-    /**
-     * Search models based on criteria
-     */
-    searchModels(params: {
+    isValid(): boolean;
+    setModels(models: OpenRouterModelRecord[]): void;
+    getAll(): OpenRouterModelRecord[];
+    get(id: string): OpenRouterModelRecord | null;
+    has(id: string): boolean;
+    search(params: {
         query?: string;
         provider?: string;
-        minContextLength?: number | string;
-        maxContextLength?: number | string;
-        maxPromptPrice?: number | string;
-        maxCompletionPrice?: number | string;
         capabilities?: {
-            functions?: boolean;
-            tools?: boolean;
             vision?: boolean;
-            json_mode?: boolean;
         };
-        limit?: number | string;
-    }): any[];
-    /**
-     * Reset the cache
-     */
-    resetCache(): void;
+        limit?: number;
+    }): OpenRouterModelRecord[];
 }

package/dist/model-cache.js

@@ -1,143 +1,46 @@
-/**
- * ModelCache - Caches OpenRouter model data to reduce API calls
- */
+function getCacheTtlMs() {
+    const raw = process.env.OPENROUTER_MODEL_CACHE_TTL_MS;
+    if (raw === undefined || raw === '')
+        return 3600000;
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 3600000;
+}
 export class ModelCache {
     static instance;
-    models;
-    lastFetchTime;
-    cacheExpiryTime; // in milliseconds (1 hour = 3600000)
-    constructor() {
-        this.models = {};
-        this.lastFetchTime = 0;
-        this.cacheExpiryTime = 3600000; // 1 hour
-    }
-    /**
-     * Get singleton instance
-     */
+    models = {};
+    fetchedAt = 0;
     static getInstance() {
-        if (!ModelCache.instance) {
-            ModelCache.instance = new ModelCache();
-        }
-        return ModelCache.instance;
+        return (ModelCache.instance ??= new ModelCache());
     }
-    /**
-     * Check if the cache is valid
-     */
-    isCacheValid() {
-        return (Object.keys(this.models).length > 0 &&
-            Date.now() - this.lastFetchTime < this.cacheExpiryTime);
+    isValid() {
+        return Object.keys(this.models).length > 0 && Date.now() - this.fetchedAt < getCacheTtlMs();
     }
-    /**
-     * Store all models
-     */
     setModels(models) {
-        this.models = {};
-        for (const model of models) {
-            this.models[model.id] = model;
-        }
-        this.lastFetchTime = Date.now();
+        this.models = Object.fromEntries(models.map((m) => [m.id, m]));
+        this.fetchedAt = Date.now();
     }
-    /**
-     * Get all cached models
-     */
-    getAllModels() {
+    getAll() {
         return Object.values(this.models);
     }
-    /**
-     * Get a specific model by ID
-     */
-    getModel(modelId) {
-        return this.models[modelId] || null;
+    get(id) {
+        return this.models[id] ?? null;
     }
-    /**
-     * Check if a model exists
-     */
-    hasModel(modelId) {
-        return !!this.models[modelId];
+    has(id) {
+        return id in this.models;
     }
-    /**
-     * Search models based on criteria
-     */
-    searchModels(params) {
-        let results = this.getAllModels();
-        // Apply text search
+    search(params) {
+        let results = this.getAll();
         if (params.query) {
-            const query = params.query.toLowerCase();
-            results = results.filter((model) => model.id.toLowerCase().includes(query) ||
-                (model.description && model.description.toLowerCase().includes(query)) ||
-                (model.provider && model.provider.toLowerCase().includes(query)));
+            const q = params.query.toLowerCase();
+            results = results.filter((m) => m.id.toLowerCase().includes(q) || m.name?.toLowerCase().includes(q));
         }
-        // Filter by provider
         if (params.provider) {
-            results = results.filter((model) => model.provider && model.provider.toLowerCase() === params.provider.toLowerCase());
-        }
-        // Filter by context length
-        if (params.minContextLength !== undefined) {
-            const minContextLength = typeof params.minContextLength === 'string'
-                ? parseInt(params.minContextLength, 10)
-                : params.minContextLength;
-            if (!isNaN(minContextLength)) {
-                results = results.filter((model) => model.context_length >= minContextLength);
-            }
+            const p = params.provider.toLowerCase();
+            results = results.filter((m) => m.id.toLowerCase().startsWith(p + '/'));
         }
-        if (params.maxContextLength !== undefined) {
-            const maxContextLength = typeof params.maxContextLength === 'string'
-                ? parseInt(params.maxContextLength, 10)
-                : params.maxContextLength;
-            if (!isNaN(maxContextLength)) {
-                results = results.filter((model) => model.context_length <= maxContextLength);
-            }
+        if (params.capabilities?.vision) {
+            results = results.filter((m) => m.architecture?.input_modalities?.includes('image'));
         }
-        // Filter by price
-        if (params.maxPromptPrice !== undefined) {
-            const maxPromptPrice = typeof params.maxPromptPrice === 'string'
-                ? parseFloat(params.maxPromptPrice)
-                : params.maxPromptPrice;
-            if (!isNaN(maxPromptPrice)) {
-                results = results.filter((model) => !model.pricing?.prompt || model.pricing.prompt <= maxPromptPrice);
-            }
-        }
-        if (params.maxCompletionPrice !== undefined) {
-            const maxCompletionPrice = typeof params.maxCompletionPrice === 'string'
-                ? parseFloat(params.maxCompletionPrice)
-                : params.maxCompletionPrice;
-            if (!isNaN(maxCompletionPrice)) {
-                results = results.filter((model) => !model.pricing?.completion ||
-                    model.pricing.completion <= maxCompletionPrice);
-            }
-        }
-        // Filter by capabilities
-        if (params.capabilities) {
-            if (params.capabilities.functions) {
-                results = results.filter((model) => model.capabilities?.function_calling);
-            }
-            if (params.capabilities.tools) {
-                results = results.filter((model) => model.capabilities?.tools);
-            }
-            if (params.capabilities.vision) {
-                results = results.filter((model) => model.capabilities?.vision);
-            }
-            if (params.capabilities.json_mode) {
-                results = results.filter((model) => model.capabilities?.json_mode);
-            }
-        }
-        // Apply limit
-        if (params.limit !== undefined) {
-            const limit = typeof params.limit === 'string'
-                ? parseInt(params.limit, 10)
-                : params.limit;
-            if (!isNaN(limit) && limit > 0) {
-                results = results.slice(0, limit);
-            }
-        }
-        return results;
-    }
-    /**
-     * Reset the cache
-     */
-    resetCache() {
-        this.models = {};
-        this.lastFetchTime = 0;
+        return results.slice(0, params.limit ?? 10);
     }
 }
-//# sourceMappingURL=model-cache.js.map

package/dist/openrouter-api.d.ts

@@ -1,26 +1,6 @@
-/**
- * Client for interacting with the OpenRouter API
- */
+import type { OpenRouterModelRecord } from './model-cache.js';
 export declare class OpenRouterAPIClient {
     private apiKey;
-    private axiosInstance;
-    private retryCount;
-    private retryDelay;
     constructor(apiKey: string);
-    /**
-     * Get all available models from OpenRouter
-     */
-    getModels(): Promise<any[]>;
-    /**
-     * Send a request to the OpenRouter API with retry functionality
-     */
-    request(endpoint: string, method: string, data?: any): Promise<any>;
-    /**
-     * Handle retryable errors
-     */
-    private handleRetryableError;
-    /**
-     * Handle request errors
-     */
-    private handleRequestError;
+    getModels(): Promise<OpenRouterModelRecord[]>;
 }

package/dist/openrouter-api.js

@@ -1,119 +1,42 @@
-import axios from 'axios';
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-/**
- * Client for interacting with the OpenRouter API
- */
+const BASE_URL = 'https://openrouter.ai/api/v1';
+async function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function fetchWithRetry(url, init, retries = 2) {
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            const res = await fetch(url, init);
+            if (res.status === 429 || res.status >= 500) {
+                if (attempt < retries)
+                    await sleep(400 * (attempt + 1));
+                else
+                    return res;
+                continue;
+            }
+            return res;
+        }
+        catch (e) {
+            lastErr = e;
+            if (attempt < retries)
+                await sleep(400 * (attempt + 1));
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
 export class OpenRouterAPIClient {
     apiKey;
-    axiosInstance;
-    retryCount = 3;
-    retryDelay = 1000; // Initial delay in ms
     constructor(apiKey) {
         this.apiKey = apiKey;
-        this.axiosInstance = axios.create({
-            baseURL: 'https://openrouter.ai/api/v1',
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                'HTTP-Referer': 'https://github.com/stabgan/openrouter-mcp-multimodal',
-                'X-Title': 'OpenRouter MCP Multimodal Server'
-            },
-            timeout: 60000 // 60 seconds timeout
-        });
     }
-    /**
-     * Get all available models from OpenRouter
-     */
     async getModels() {
-        try {
-            const response = await this.axiosInstance.get('/models');
-            return response.data.data;
-        }
-        catch (error) {
-            this.handleRequestError(error);
-            return [];
-        }
-    }
-    /**
-     * Send a request to the OpenRouter API with retry functionality
-     */
-    async request(endpoint, method, data) {
-        let lastError = null;
-        let retries = 0;
-        while (retries <= this.retryCount) {
-            try {
-                const response = await this.axiosInstance.request({
-                    url: endpoint,
-                    method,
-                    data
-                });
-                return response.data;
-            }
-            catch (error) {
-                lastError = this.handleRetryableError(error, retries);
-                retries++;
-                if (retries <= this.retryCount) {
-                    // Exponential backoff with jitter
-                    const delay = this.retryDelay * Math.pow(2, retries - 1) * (0.5 + Math.random() * 0.5);
-                    console.error(`Retrying in ${Math.round(delay)}ms (${retries}/${this.retryCount})`);
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                }
-            }
-        }
-        // If we get here, all retries failed
-        throw lastError || new Error('Request failed after multiple retries');
-    }
-    /**
-     * Handle retryable errors
-     */
-    handleRetryableError(error, retryCount) {
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            // Rate limiting (429) or server errors (5xx)
-            if (axiosError.response?.status === 429 || (axiosError.response?.status && axiosError.response.status >= 500)) {
-                console.error(`Request error (retry ${retryCount}): ${axiosError.message}`);
-                if (axiosError.response?.status === 429) {
-                    console.error('Rate limit exceeded. Retrying with backoff...');
-                }
-                return new Error(`OpenRouter API error: ${axiosError.response?.status} ${axiosError.message}`);
-            }
-            // For other status codes, don't retry
-            if (axiosError.response) {
-                const responseData = axiosError.response.data;
-                const message = responseData?.error?.message || axiosError.message;
-                throw new McpError(ErrorCode.InternalError, `OpenRouter API error: ${message}`);
-            }
-        }
-        // Network errors should be retried
-        console.error(`Network error (retry ${retryCount}): ${error.message}`);
-        return new Error(`Network error: ${error.message}`);
-    }
-    /**
-     * Handle request errors
-     */
-    handleRequestError(error) {
-        console.error('Error in OpenRouter API request:', error);
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            if (axiosError.response) {
-                const status = axiosError.response.status;
-                const responseData = axiosError.response.data;
-                const message = responseData?.error?.message || axiosError.message;
-                if (status === 401 || status === 403) {
-                    throw new McpError(ErrorCode.InvalidRequest, `Authentication error: ${message}`);
-                }
-                else if (status === 429) {
-                    throw new McpError(ErrorCode.InternalError, `Rate limit exceeded: ${message}`);
-                }
-                else {
-                    throw new McpError(ErrorCode.InternalError, `OpenRouter API error (${status}): ${message}`);
-                }
-            }
-            else if (axiosError.request) {
-                throw new McpError(ErrorCode.ConnectionClosed, `Network error: ${axiosError.message}`);
-            }
-        }
-        throw new McpError(ErrorCode.InternalError, `Unknown error: ${error.message || 'No error message'}`);
+        const res = await fetchWithRetry(`${BASE_URL}/models`, {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+            signal: AbortSignal.timeout(30000),
+        }, 2);
+        if (!res.ok)
+            throw new Error(`Failed to fetch models: HTTP ${res.status}`);
+        const data = (await res.json());
+        return data.data ?? [];
     }
 }
-//# sourceMappingURL=openrouter-api.js.map

package/dist/tool-handlers/analyze-image.d.ts

@@ -4,9 +4,6 @@ export interface AnalyzeImageToolRequest {
     question?: string;
     model?: string;
 }
-/**
- * Handler for analyzing a single image
- */
 export declare function handleAnalyzeImage(request: {
     params: {
         arguments: AnalyzeImageToolRequest;
@@ -16,23 +13,11 @@ export declare function handleAnalyzeImage(request: {
         type: string;
         text: string;
     }[];
-    metadata: {
-        model: string;
-        usage: OpenAI.Completions.CompletionUsage | undefined;
-        error_type?: undefined;
-        error_message?: undefined;
-    };
-    isError?: undefined;
+    isError: boolean;
 } | {
     content: {
         type: string;
         text: string;
     }[];
-    isError: boolean;
-    metadata: {
-        error_type: string;
-        error_message: string;
-        model?: undefined;
-        usage?: undefined;
-    };
+    isError?: undefined;
 }>;