@stabgan/openrouter-mcp-multimodal 2.0.0 → 3.0.0

package/dist/__tests__/image-utils.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getMimeType, fetchImage, optimizeImage, prepareImageUrl, isBlockedIPv4, assertUrlSafeForFetch, } from '../tool-handlers/image-utils.js';
-import path from 'path';
-import { writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-describe('getMimeType', () => {
-    it('should return correct MIME types', () => {
-        expect(getMimeType('photo.png')).toBe('image/png');
-        expect(getMimeType('photo.jpg')).toBe('image/jpeg');
-        expect(getMimeType('photo.jpeg')).toBe('image/jpeg');
-        expect(getMimeType('photo.webp')).toBe('image/webp');
-        expect(getMimeType('photo.gif')).toBe('image/gif');
-        expect(getMimeType('photo.bmp')).toBe('image/bmp');
-    });
-    it('should default to image/jpeg for unknown extensions', () => {
-        expect(getMimeType('file.xyz')).toBe('image/jpeg');
-        expect(getMimeType('noext')).toBe('image/jpeg');
-    });
-});
-describe('fetchImage', () => {
-    it('should decode base64 data URLs', async () => {
-        const data = Buffer.from('hello').toString('base64');
-        const buf = await fetchImage(`data:image/png;base64,${data}`);
-        expect(buf.toString()).toBe('hello');
-    });
-    it('should reject invalid data URLs', async () => {
-        await expect(fetchImage('data:invalid')).rejects.toThrow('Invalid data URL');
-    });
-    it('should read local files', async () => {
-        const tmpFile = path.join(tmpdir(), `test-img-${Date.now()}.txt`);
-        writeFileSync(tmpFile, 'test-content');
-        const buf = await fetchImage(tmpFile);
-        expect(buf.toString()).toBe('test-content');
-    });
-    it('should throw on missing files', async () => {
-        await expect(fetchImage('/nonexistent/path/image.png')).rejects.toThrow();
-    });
-    it('should reject private IPv4 URLs', async () => {
-        await expect(fetchImage('http://127.0.0.1:8080/x')).rejects.toThrow();
-        await expect(fetchImage('http://192.168.1.1/x')).rejects.toThrow();
-    });
-    it('should reject localhost hostnames', async () => {
-        await expect(assertUrlSafeForFetch('http://localhost/foo')).rejects.toThrow();
-    });
-});
-describe('isBlockedIPv4', () => {
-    it('identifies loopback and RFC1918', () => {
-        expect(isBlockedIPv4('127.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('10.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('8.8.8.8')).toBe(false);
-    });
-});
-describe('optimizeImage', () => {
-    it('should return base64 string for any buffer', async () => {
-        // Even without sharp, fallback should return base64
-        const buf = Buffer.from('fake-image-data');
-        const result = await optimizeImage(buf);
-        expect(typeof result).toBe('string');
-        expect(result.length).toBeGreaterThan(0);
-    });
-});
-describe('prepareImageUrl', () => {
-    it('should pass through data URLs unchanged', async () => {
-        const dataUrl = 'data:image/png;base64,iVBORw0KGgo=';
-        const result = await prepareImageUrl(dataUrl);
-        expect(result).toBe(dataUrl);
-    });
-    it('should convert local files to data URLs', async () => {
-        // Create a tiny valid file
-        const tmpFile = path.join(tmpdir(), `test-prep-${Date.now()}.png`);
-        writeFileSync(tmpFile, Buffer.from([0x89, 0x50, 0x4e, 0x47])); // PNG magic bytes
-        const result = await prepareImageUrl(tmpFile);
-        expect(result).toMatch(/^data:image\/png;base64,/);
-    });
-});

package/dist/__tests__/integration.test.d.ts

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

package/dist/__tests__/integration.test.js

@@ -1,219 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { config } from 'dotenv';
-import OpenAI from 'openai';
-import { handleChatCompletion } from '../tool-handlers/chat-completion.js';
-import { handleAnalyzeImage } from '../tool-handlers/analyze-image.js';
-import { handleSearchModels } from '../tool-handlers/search-models.js';
-import { handleGetModelInfo } from '../tool-handlers/get-model-info.js';
-import { handleValidateModel } from '../tool-handlers/validate-model.js';
-import { handleAnalyzeAudio } from '../tool-handlers/analyze-audio.js';
-import { handleGenerateAudio } from '../tool-handlers/generate-audio.js';
-import { OpenRouterAPIClient } from '../openrouter-api.js';
-import { ModelCache } from '../model-cache.js';
-import path from 'path';
-import { promises as fsPromises } from 'fs';
-config(); // Load .env
-const API_KEY = process.env.OPENROUTER_API_KEY;
-const DEFAULT_MODEL = 'nvidia/nemotron-nano-12b-v2-vl:free';
-// Skip all integration tests if no API key
-const describeIf = API_KEY ? describe : describe.skip;
-describeIf('Integration: chat_completion', () => {
-    let openai;
-    beforeAll(() => {
-        openai = new OpenAI({ apiKey: API_KEY, baseURL: 'https://openrouter.ai/api/v1' });
-    });
-    it('should complete a simple text chat', async () => {
-        const result = await handleChatCompletion({
-            params: {
-                arguments: { messages: [{ role: 'user', content: 'Say "hello" and nothing else.' }] },
-            },
-        }, openai, DEFAULT_MODEL);
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text.toLowerCase()).toContain('hello');
-    });
-    it('should return error for empty messages', async () => {
-        const result = await handleChatCompletion({ params: { arguments: { messages: [] } } }, openai, DEFAULT_MODEL);
-        expect(result.isError).toBe(true);
-    });
-});
-describeIf('Integration: analyze_image', () => {
-    let openai;
-    beforeAll(() => {
-        openai = new OpenAI({ apiKey: API_KEY, baseURL: 'https://openrouter.ai/api/v1' });
-    });
-    it('should analyze the test image from file path', async () => {
-        const testImg = path.resolve('test.png');
-        const result = await handleAnalyzeImage({ params: { arguments: { image_path: testImg, question: 'Describe this image briefly.' } } }, openai, DEFAULT_MODEL);
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text.length).toBeGreaterThan(10);
-    });
-    it('should analyze an image from URL', async () => {
-        const result = await handleAnalyzeImage({
-            params: {
-                arguments: {
-                    image_path: 'https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png',
-                    question: 'What do you see?',
-                },
-            },
-        }, openai, DEFAULT_MODEL);
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text.length).toBeGreaterThan(10);
-    });
-    it('should return error for missing image_path', async () => {
-        const result = await handleAnalyzeImage({ params: { arguments: { image_path: '' } } }, openai, DEFAULT_MODEL);
-        expect(result.isError).toBe(true);
-    });
-});
-describeIf('Integration: search_models', () => {
-    let apiClient;
-    let cache;
-    beforeAll(() => {
-        apiClient = new OpenRouterAPIClient(API_KEY);
-        cache = ModelCache.getInstance();
-    });
-    it('should fetch and search models', async () => {
-        const result = await handleSearchModels({ params: { arguments: { query: 'free', limit: 5 } } }, apiClient, cache);
-        expect(result.isError).toBeFalsy();
-        const models = JSON.parse(result.content[0].text);
-        expect(models.length).toBeGreaterThan(0);
-        expect(models.length).toBeLessThanOrEqual(5);
-    });
-    it('should filter by vision capability', async () => {
-        const result = await handleSearchModels({ params: { arguments: { capabilities: { vision: true }, limit: 3 } } }, apiClient, cache);
-        const models = JSON.parse(result.content[0].text);
-        expect(models.every((m) => m.architecture?.input_modalities?.includes('image'))).toBe(true);
-    });
-});
-describeIf('Integration: get_model_info + validate_model', () => {
-    let apiClient;
-    let cache;
-    beforeAll(async () => {
-        apiClient = new OpenRouterAPIClient(API_KEY);
-        cache = ModelCache.getInstance();
-    });
-    it('should get info for a known model', async () => {
-        const result = await handleGetModelInfo({ params: { arguments: { model: DEFAULT_MODEL } } }, cache, apiClient);
-        expect(result.isError).toBeFalsy();
-        const info = JSON.parse(result.content[0].text);
-        expect(info.id).toBe(DEFAULT_MODEL);
-    });
-    it('should return error for unknown model', async () => {
-        const result = await handleGetModelInfo({ params: { arguments: { model: 'nonexistent/model-xyz' } } }, cache, apiClient);
-        expect(result.isError).toBe(true);
-    });
-    it('should validate a real model', async () => {
-        const result = await handleValidateModel({ params: { arguments: { model: DEFAULT_MODEL } } }, cache, apiClient);
-        const parsed = JSON.parse(result.content[0].text);
-        expect(parsed.valid).toBe(true);
-    });
-    it('should invalidate a fake model', async () => {
-        const result = await handleValidateModel({ params: { arguments: { model: 'fake/model' } } }, cache, apiClient);
-        const parsed = JSON.parse(result.content[0].text);
-        expect(parsed.valid).toBe(false);
-    });
-});
-describeIf('Integration: analyze_audio', () => {
-    let openai;
-    beforeAll(() => {
-        openai = new OpenAI({ apiKey: API_KEY, baseURL: 'https://openrouter.ai/api/v1' });
-    });
-    it('should analyze audio from a data URL', async () => {
-        // Create a minimal WAV file (44-byte header + tiny PCM data) as a data URL
-        const header = Buffer.alloc(44);
-        header.write('RIFF', 0);
-        header.writeUInt32LE(36 + 100, 4);
-        header.write('WAVE', 8);
-        header.write('fmt ', 12);
-        header.writeUInt32LE(16, 16);
-        header.writeUInt16LE(1, 20);
-        header.writeUInt16LE(1, 22);
-        header.writeUInt32LE(16000, 24);
-        header.writeUInt32LE(32000, 28);
-        header.writeUInt16LE(2, 32);
-        header.writeUInt16LE(16, 34);
-        header.write('data', 36);
-        header.writeUInt32LE(100, 40);
-        const pcmData = Buffer.alloc(100); // silence
-        const wavBuffer = Buffer.concat([header, pcmData]);
-        const b64 = wavBuffer.toString('base64');
-        const result = await handleAnalyzeAudio({
-            params: {
-                arguments: {
-                    audio_path: `data:audio/wav;base64,${b64}`,
-                    question: 'What do you hear?',
-                    model: 'google/gemini-2.5-flash',
-                },
-            },
-        }, openai);
-        if (result.isError) {
-            // 402 = insufficient balance — code works, account needs credits
-            const errText = result.content[0].text;
-            console.log('analyze_audio error:', errText);
-            if (errText.includes('402') || errText.includes('balance')) {
-                // Expected when account has no audio credits — test the code path worked
-                expect(errText).toContain('402');
-                return;
-            }
-        }
-        expect(result.isError).toBeFalsy();
-        expect(result.content[0].text.length).toBeGreaterThan(0);
-    }, 30000);
-    it('should return error for missing audio_path', async () => {
-        const result = await handleAnalyzeAudio({ params: { arguments: { audio_path: '' } } }, openai);
-        expect(result.isError).toBe(true);
-    });
-});
-describeIf('Integration: generate_audio', () => {
-    let openai;
-    beforeAll(() => {
-        openai = new OpenAI({ apiKey: API_KEY, baseURL: 'https://openrouter.ai/api/v1' });
-    });
-    it('should generate audio from a text prompt', async () => {
-        const result = await handleGenerateAudio({
-            params: {
-                arguments: {
-                    prompt: 'Say hello world',
-                    model: 'openai/gpt-4o-mini-audio-preview',
-                    voice: 'alloy',
-                },
-            },
-        }, openai);
-        // Either we get audio back or a graceful error (model availability varies)
-        expect(result.content.length).toBeGreaterThan(0);
-        if (!result.isError) {
-            const audioContent = result.content.find((c) => c.type === 'audio');
-            if (audioContent) {
-                expect(audioContent.data.length).toBeGreaterThan(0);
-            }
-        }
-    }, 60000);
-    it('should save audio to file and auto-correct extension', async () => {
-        const tmpPath = path.join('/tmp', `test-gen-audio-${Date.now()}.wav`);
-        const result = await handleGenerateAudio({
-            params: {
-                arguments: {
-                    prompt: 'Say the word test',
-                    model: 'openai/gpt-4o-mini-audio-preview',
-                    voice: 'alloy',
-                    save_path: tmpPath,
-                },
-            },
-        }, openai);
-        if (!result.isError) {
-            const textContent = result.content.find((c) => c.type === 'text');
-            expect(textContent.text).toContain('Audio saved to:');
-            // Clean up - the actual path may have been corrected
-            const savedPath = textContent.text.match(/Audio saved to: (.+?)(\s|\n|$)/)?.[1];
-            if (savedPath) {
-                try {
-                    await fsPromises.unlink(savedPath);
-                }
-                catch { /* ignore */ }
-            }
-        }
-    }, 60000);
-    it('should return error for empty prompt', async () => {
-        const result = await handleGenerateAudio({ params: { arguments: { prompt: '' } } }, openai);
-        expect(result.isError).toBe(true);
-    });
-});

package/dist/__tests__/model-cache.test.d.ts

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

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

@@ -1,96 +0,0 @@
-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);
-    });
-});