@stabgan/openrouter-mcp-multimodal 2.0.0 → 3.0.0

package/dist/tool-handlers.js

@@ -1,4 +1,4 @@
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ErrorCode as McpErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import OpenAI from 'openai';
 import { ModelCache } from './model-cache.js';
 import { OpenRouterAPIClient } from './openrouter-api.js';
@@ -10,6 +10,8 @@ import { handleValidateModel } from './tool-handlers/validate-model.js';
 import { handleGenerateImage } from './tool-handlers/generate-image.js';
 import { handleAnalyzeAudio } from './tool-handlers/analyze-audio.js';
 import { handleGenerateAudio } from './tool-handlers/generate-audio.js';
+import { handleAnalyzeVideo } from './tool-handlers/analyze-video.js';
+import { handleGenerateVideo, handleGetVideoStatus, } from './tool-handlers/generate-video.js';
 function wrapToolArgs(a) {
     return { params: { arguments: a ?? {} } };
 }
@@ -33,6 +35,11 @@ export class ToolHandlers {
                 {
                     name: 'chat_completion',
                     description: 'Send messages to an OpenRouter model and get a response',
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -60,6 +67,11 @@ export class ToolHandlers {
                 {
                     name: 'analyze_image',
                     description: 'Analyze an image using a vision model',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -70,15 +82,75 @@ export class ToolHandlers {
                         required: ['image_path'],
                     },
                 },
+                {
+                    name: 'analyze_audio',
+                    description: 'Analyze or transcribe an audio file using a multimodal model',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            audio_path: {
+                                type: 'string',
+                                description: 'File path, URL, or data URL (base64-encoded audio)',
+                            },
+                            question: {
+                                type: 'string',
+                                description: 'Question or instruction about the audio (default: transcribe)',
+                            },
+                            model: { type: 'string' },
+                        },
+                        required: ['audio_path'],
+                    },
+                },
+                {
+                    name: 'analyze_video',
+                    description: 'Analyze or transcribe a video file using a multimodal model. Accepts mp4, mpeg, mov, or webm from a local file path, HTTP(S) URL, or base64 data URL. Default model: google/gemini-2.5-flash.',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            video_path: {
+                                type: 'string',
+                                description: 'File path, HTTP(S) URL, or base64 data URL. Supported formats: mp4, mpeg, mov, webm.',
+                            },
+                            question: {
+                                type: 'string',
+                                description: 'Question or instruction about the video (default: describe).',
+                            },
+                            model: { type: 'string', description: 'Override the model ID.' },
+                        },
+                        required: ['video_path'],
+                    },
+                },
                 {
                     name: 'search_models',
                     description: 'Search available OpenRouter models',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
                             query: { type: 'string' },
                             provider: { type: 'string' },
-                            capabilities: { type: 'object', properties: { vision: { type: 'boolean' } } },
+                            capabilities: {
+                                type: 'object',
+                                properties: {
+                                    vision: { type: 'boolean' },
+                                    audio: { type: 'boolean' },
+                                    video: { type: 'boolean' },
+                                },
+                            },
                             limit: { type: 'number', minimum: 1, maximum: 50 },
                         },
                     },
@@ -86,6 +158,11 @@ export class ToolHandlers {
                 {
                     name: 'get_model_info',
                     description: 'Get details about a specific model',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: { model: { type: 'string' } },
@@ -95,6 +172,11 @@ export class ToolHandlers {
                 {
                     name: 'validate_model',
                     description: 'Check if a model ID exists',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: { model: { type: 'string' } },
@@ -104,46 +186,136 @@ export class ToolHandlers {
                 {
                     name: 'generate_image',
                     description: 'Generate an image from a text prompt',
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
                             prompt: { type: 'string' },
                             model: { type: 'string' },
-                            save_path: { type: 'string' },
+                            save_path: {
+                                type: 'string',
+                                description: 'Optional path to save the image. Routed through the OPENROUTER_OUTPUT_DIR sandbox.',
+                            },
                         },
                         required: ['prompt'],
                     },
                 },
                 {
-                    name: 'analyze_audio',
-                    description: 'Analyze or transcribe an audio file using a multimodal model',
+                    name: 'generate_audio',
+                    description: 'Generate audio from a text prompt. Conversational models (e.g. openai/gpt-audio) respond in spoken audio. Music models (e.g. google/lyria-3-clip-preview) need a structured prompt. Output format is auto-detected and file extension is corrected automatically.',
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            audio_path: { type: 'string', description: 'File path, URL, or data URL (base64-encoded audio)' },
-                            question: { type: 'string', description: 'Question or instruction about the audio (default: transcribe)' },
-                            model: { type: 'string' },
+                            prompt: { type: 'string', description: 'Text input' },
+                            model: { type: 'string', description: 'Model ID (default: openai/gpt-audio)' },
+                            voice: { type: 'string', description: 'Voice name (default: alloy)' },
+                            format: {
+                                type: 'string',
+                                description: 'Requested format: pcm16 (default), mp3, flac, opus',
+                            },
+                            save_path: {
+                                type: 'string',
+                                description: 'Optional path to save the audio. Extension auto-corrected and routed through OPENROUTER_OUTPUT_DIR sandbox.',
+                            },
                         },
-                        required: ['audio_path'],
+                        required: ['prompt'],
                     },
                 },
                 {
-                    name: 'generate_audio',
-                    description: 'Generate audio from a text prompt. Conversational models (e.g. openai/gpt-audio) respond in spoken audio. ' +
-                        'Music models (e.g. google/lyria-3-clip-preview) need a structured prompt. ' +
-                        'Output format is auto-detected and file extension is corrected automatically.',
+                    name: 'generate_video',
+                    description: 'Generate a video from a text prompt using an OpenRouter video-generation model (default: google/veo-3.1). ' +
+                        'Submits an async job, polls until completion or max_wait_ms, then downloads the result. ' +
+                        'Optionally conditioned on first/last-frame images or reference images. ' +
+                        'Large outputs are auto-saved when save_path is provided and path-sandboxed.',
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                    },
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            prompt: { type: 'string', description: 'Text input' },
-                            model: { type: 'string', description: 'Model ID (default: openai/gpt-audio)' },
-                            voice: { type: 'string', description: 'Voice name (default: alloy)' },
-                            format: { type: 'string', description: 'Requested format: pcm16 (default), mp3, flac, opus' },
-                            save_path: { type: 'string', description: 'Path to save audio file. Extension auto-corrected.' },
+                            prompt: { type: 'string', description: 'Text description of the desired video.' },
+                            model: { type: 'string', description: 'Override the video model ID.' },
+                            resolution: {
+                                type: 'string',
+                                description: '480p / 720p / 1080p / 1K / 2K / 4K (model-dependent).',
+                            },
+                            aspect_ratio: {
+                                type: 'string',
+                                description: '16:9 / 9:16 / 1:1 / 4:3 / 3:4 / 21:9 / 9:21 (model-dependent).',
+                            },
+                            duration: {
+                                type: 'number',
+                                minimum: 1,
+                                description: 'Duration in seconds (model-dependent).',
+                            },
+                            seed: { type: 'number', description: 'Deterministic seed when supported.' },
+                            first_frame_image: {
+                                type: 'string',
+                                description: 'Optional image (path, URL, or data URL) used as the first frame for image-to-video.',
+                            },
+                            last_frame_image: {
+                                type: 'string',
+                                description: 'Optional image used as the last frame for frame transitions.',
+                            },
+                            reference_images: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Optional style/content reference images.',
+                            },
+                            provider: {
+                                type: 'object',
+                                description: 'Provider-specific passthrough options keyed by provider slug.',
+                            },
+                            save_path: {
+                                type: 'string',
+                                description: 'Where to save the video. Routed through the OPENROUTER_OUTPUT_DIR sandbox; extension auto-corrected.',
+                            },
+                            max_wait_ms: {
+                                type: 'number',
+                                minimum: 10000,
+                                description: 'Total time to wait for the async job before returning a resumable handle (default 600000 ms).',
+                            },
+                            poll_interval_ms: {
+                                type: 'number',
+                                minimum: 2000,
+                                description: 'Polling cadence (default 15000 ms).',
+                            },
                         },
                         required: ['prompt'],
                     },
                 },
+                {
+                    name: 'get_video_status',
+                    description: 'Resume a previously submitted video generation job by id. Returns the latest status; if completed, ' +
+                        'downloads the video (and saves it when save_path is provided).',
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                    },
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            video_id: { type: 'string', description: 'Job id from a previous generate_video call.' },
+                            save_path: {
+                                type: 'string',
+                                description: 'Optional save path (applies when the job is already completed).',
+                            },
+                        },
+                        required: ['video_id'],
+                    },
+                },
             ],
         }));
         server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -153,6 +325,10 @@ export class ToolHandlers {
                     return handleChatCompletion(wrapToolArgs(args), this.openai, this.defaultModel);
                 case 'analyze_image':
                     return handleAnalyzeImage(wrapToolArgs(args), this.openai, this.defaultModel);
+                case 'analyze_audio':
+                    return handleAnalyzeAudio(wrapToolArgs(args), this.openai, this.defaultModel);
+                case 'analyze_video':
+                    return handleAnalyzeVideo(wrapToolArgs(args), this.openai, this.defaultModel);
                 case 'search_models':
                     return handleSearchModels(wrapToolArgs(args), this.apiClient, this.modelCache);
                 case 'get_model_info':
@@ -161,12 +337,14 @@ export class ToolHandlers {
                     return handleValidateModel(wrapToolArgs(args), this.modelCache, this.apiClient);
                 case 'generate_image':
                     return handleGenerateImage(wrapToolArgs(args), this.openai);
-                case 'analyze_audio':
-                    return handleAnalyzeAudio(wrapToolArgs(args), this.openai, this.defaultModel);
                 case 'generate_audio':
                     return handleGenerateAudio(wrapToolArgs(args), this.openai);
+                case 'generate_video':
+                    return handleGenerateVideo(wrapToolArgs(args), this.apiClient);
+                case 'get_video_status':
+                    return handleGetVideoStatus(wrapToolArgs(args), this.apiClient);
                 default:
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                    throw new McpError(McpErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }
         });
     }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stabgan/openrouter-mcp-multimodal",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "mcpName": "io.github.stabgan/openrouter-multimodal",
-  "description": "MCP server for OpenRouter with text chat, image analysis, image generation, audio analysis, and audio generation",
+  "description": "MCP server for OpenRouter with text chat, image analysis + generation, audio analysis + generation, video analysis, and video generation (Veo 3.1 / Sora 2 Pro / Seedance / Wan)",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "build": "tsc && shx chmod +x dist/*.js",
-    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
     "lint": "eslint src",
     "format": "prettier --write \"src/**/*.ts\" *.json \"*.md\"",

package/dist/__tests__/audio-utils.test.d.ts

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

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

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getAudioFormat, getAudioMimeType, prepareAudioData, isBlockedIPv4, assertUrlSafeForFetch, SUPPORTED_AUDIO_FORMATS, } from '../tool-handlers/audio-utils.js';
-import path from 'path';
-import { writeFileSync, unlinkSync } from 'fs';
-import { tmpdir } from 'os';
-describe('getAudioFormat', () => {
-    it('returns correct format for supported extensions', () => {
-        expect(getAudioFormat('audio.wav')).toBe('wav');
-        expect(getAudioFormat('audio.mp3')).toBe('mp3');
-        expect(getAudioFormat('audio.flac')).toBe('flac');
-        expect(getAudioFormat('audio.ogg')).toBe('ogg');
-        expect(getAudioFormat('audio.aac')).toBe('aac');
-        expect(getAudioFormat('audio.m4a')).toBe('m4a');
-        expect(getAudioFormat('audio.aiff')).toBe('aiff');
-    });
-    it('returns undefined for unsupported extensions', () => {
-        expect(getAudioFormat('audio.xyz')).toBeUndefined();
-        expect(getAudioFormat('audio.mid')).toBeUndefined();
-        expect(getAudioFormat('noext')).toBeUndefined();
-    });
-    it('returns undefined for API-only formats (pcm16/pcm24 are not file extensions)', () => {
-        expect(getAudioFormat('audio.pcm16')).toBeUndefined();
-        expect(getAudioFormat('audio.pcm24')).toBeUndefined();
-    });
-    it('handles uppercase extensions', () => {
-        expect(getAudioFormat('audio.WAV')).toBe('wav');
-        expect(getAudioFormat('audio.MP3')).toBe('mp3');
-        expect(getAudioFormat('audio.FLAC')).toBe('flac');
-    });
-});
-describe('getAudioMimeType', () => {
-    it('returns correct MIME types', () => {
-        expect(getAudioMimeType('wav')).toBe('audio/wav');
-        expect(getAudioMimeType('mp3')).toBe('audio/mpeg');
-        expect(getAudioMimeType('flac')).toBe('audio/flac');
-        expect(getAudioMimeType('ogg')).toBe('audio/ogg');
-        expect(getAudioMimeType('aac')).toBe('audio/aac');
-        expect(getAudioMimeType('m4a')).toBe('audio/mp4');
-        expect(getAudioMimeType('aiff')).toBe('audio/aiff');
-        expect(getAudioMimeType('pcm16')).toBe('audio/pcm');
-        expect(getAudioMimeType('pcm24')).toBe('audio/pcm');
-    });
-});
-describe('SUPPORTED_AUDIO_FORMATS', () => {
-    it('includes file formats and API formats', () => {
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('wav');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('mp3');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('flac');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('ogg');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('aac');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('m4a');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('pcm16');
-        expect(SUPPORTED_AUDIO_FORMATS).toContain('pcm24');
-    });
-});
-describe('prepareAudioData', () => {
-    it('decodes base64 data URLs with correct format', async () => {
-        const audioData = Buffer.from('fake-audio-data').toString('base64');
-        const result = await prepareAudioData(`data:audio/wav;base64,${audioData}`);
-        expect(result.data).toBe(audioData);
-        expect(result.format).toBe('wav');
-    });
-    it('maps audio/mpeg MIME to mp3 format', async () => {
-        const audioData = Buffer.from('fake-audio-data').toString('base64');
-        const result = await prepareAudioData(`data:audio/mpeg;base64,${audioData}`);
-        expect(result.data).toBe(audioData);
-        expect(result.format).toBe('mp3');
-    });
-    it('rejects invalid data URLs', async () => {
-        await expect(prepareAudioData('data:invalid')).rejects.toThrow('Invalid data URL');
-    });
-    it('rejects unsupported MIME types', async () => {
-        const audioData = Buffer.from('fake').toString('base64');
-        await expect(prepareAudioData(`data:audio/xyz;base64,${audioData}`)).rejects.toThrow('Unsupported audio format');
-    });
-    it('reads local files and returns base64 with format', async () => {
-        const tmpFile = path.join(tmpdir(), `test-audio-${Date.now()}.wav`);
-        writeFileSync(tmpFile, Buffer.from('fake-audio-content'));
-        try {
-            const result = await prepareAudioData(tmpFile);
-            expect(result.data).toBe(Buffer.from('fake-audio-content').toString('base64'));
-            expect(result.format).toBe('wav');
-        }
-        finally {
-            unlinkSync(tmpFile);
-        }
-    });
-    it('throws on missing files', async () => {
-        await expect(prepareAudioData('/nonexistent/path/audio.wav')).rejects.toThrow();
-    });
-    it('throws on unsupported file extensions', async () => {
-        const tmpFile = path.join(tmpdir(), `test-audio-${Date.now()}.xyz`);
-        writeFileSync(tmpFile, Buffer.from('fake'));
-        try {
-            await expect(prepareAudioData(tmpFile)).rejects.toThrow('Unsupported audio format');
-        }
-        finally {
-            unlinkSync(tmpFile);
-        }
-    });
-    it('rejects private IPv4 URLs', async () => {
-        await expect(prepareAudioData('http://127.0.0.1:8080/audio.wav')).rejects.toThrow();
-        await expect(prepareAudioData('http://192.168.1.1/audio.mp3')).rejects.toThrow();
-    });
-    it('rejects localhost hostnames', async () => {
-        await expect(assertUrlSafeForFetch('http://localhost/audio.wav')).rejects.toThrow();
-    });
-});
-describe('isBlockedIPv4 (re-exported from fetch-utils)', () => {
-    it('identifies loopback and RFC1918', () => {
-        expect(isBlockedIPv4('127.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('10.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('192.168.1.1')).toBe(true);
-        expect(isBlockedIPv4('172.16.0.1')).toBe(true);
-        expect(isBlockedIPv4('8.8.8.8')).toBe(false);
-    });
-    it('blocks metadata endpoint IP', () => {
-        expect(isBlockedIPv4('169.254.169.254')).toBe(true);
-    });
-});

package/dist/__tests__/fetch-utils.test.d.ts

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

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

@@ -1,76 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readEnvInt, isBlockedIPv4, assertUrlSafeForFetch } from '../tool-handlers/fetch-utils.js';
-describe('readEnvInt', () => {
-    it('returns fallback when env var is missing', () => {
-        delete process.env['TEST_MISSING_VAR'];
-        expect(readEnvInt('TEST_MISSING_VAR', 42)).toBe(42);
-    });
-    it('returns fallback when env var is empty', () => {
-        process.env['TEST_EMPTY_VAR'] = '';
-        expect(readEnvInt('TEST_EMPTY_VAR', 42)).toBe(42);
-        delete process.env['TEST_EMPTY_VAR'];
-    });
-    it('parses valid integer', () => {
-        process.env['TEST_INT_VAR'] = '100';
-        expect(readEnvInt('TEST_INT_VAR', 42)).toBe(100);
-        delete process.env['TEST_INT_VAR'];
-    });
-    it('returns fallback for non-numeric value', () => {
-        process.env['TEST_NAN_VAR'] = 'abc';
-        expect(readEnvInt('TEST_NAN_VAR', 42)).toBe(42);
-        delete process.env['TEST_NAN_VAR'];
-    });
-    it('returns fallback when value is below min', () => {
-        process.env['TEST_LOW_VAR'] = '0';
-        expect(readEnvInt('TEST_LOW_VAR', 42, 1)).toBe(42);
-        delete process.env['TEST_LOW_VAR'];
-    });
-});
-describe('isBlockedIPv4', () => {
-    it('blocks loopback', () => {
-        expect(isBlockedIPv4('127.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('127.255.255.255')).toBe(true);
-    });
-    it('blocks RFC1918 10.x', () => {
-        expect(isBlockedIPv4('10.0.0.1')).toBe(true);
-        expect(isBlockedIPv4('10.255.255.255')).toBe(true);
-    });
-    it('blocks RFC1918 172.16-31.x', () => {
-        expect(isBlockedIPv4('172.16.0.1')).toBe(true);
-        expect(isBlockedIPv4('172.31.255.255')).toBe(true);
-    });
-    it('blocks RFC1918 192.168.x', () => {
-        expect(isBlockedIPv4('192.168.0.1')).toBe(true);
-        expect(isBlockedIPv4('192.168.255.255')).toBe(true);
-    });
-    it('blocks link-local 169.254.x', () => {
-        expect(isBlockedIPv4('169.254.169.254')).toBe(true);
-    });
-    it('blocks CGNAT 100.64-127.x', () => {
-        expect(isBlockedIPv4('100.64.0.1')).toBe(true);
-        expect(isBlockedIPv4('100.127.255.255')).toBe(true);
-    });
-    it('allows public IPs', () => {
-        expect(isBlockedIPv4('8.8.8.8')).toBe(false);
-        expect(isBlockedIPv4('1.1.1.1')).toBe(false);
-        expect(isBlockedIPv4('142.250.80.46')).toBe(false);
-    });
-});
-describe('assertUrlSafeForFetch', () => {
-    it('rejects localhost', async () => {
-        await expect(assertUrlSafeForFetch('http://localhost/foo')).rejects.toThrow('Blocked host');
-    });
-    it('rejects private IPv4', async () => {
-        await expect(assertUrlSafeForFetch('http://127.0.0.1/foo')).rejects.toThrow('Blocked host');
-        await expect(assertUrlSafeForFetch('http://192.168.1.1/foo')).rejects.toThrow('Blocked host');
-    });
-    it('rejects non-HTTP protocols', async () => {
-        await expect(assertUrlSafeForFetch('ftp://example.com/foo')).rejects.toThrow('Only HTTP(S)');
-    });
-    it('rejects URLs with credentials', async () => {
-        await expect(assertUrlSafeForFetch('http://user:pass@example.com/foo')).rejects.toThrow('credentials');
-    });
-    it('rejects invalid URLs', async () => {
-        await expect(assertUrlSafeForFetch('not-a-url')).rejects.toThrow('Invalid URL');
-    });
-});

package/dist/__tests__/generate-audio.test.d.ts

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

package/dist/__tests__/generate-audio.test.js

@@ -1,90 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createWavHeader, detectAudioFormat, wrapPcmInWav, replaceExtension, } from '../tool-handlers/generate-audio.js';
-describe('createWavHeader', () => {
-    it('produces a 44-byte buffer', () => {
-        const header = createWavHeader(1000);
-        expect(header.length).toBe(44);
-    });
-    it('starts with RIFF...WAVE', () => {
-        const header = createWavHeader(1000);
-        expect(header.subarray(0, 4).toString('ascii')).toBe('RIFF');
-        expect(header.subarray(8, 12).toString('ascii')).toBe('WAVE');
-    });
-    it('has correct file size field (36 + dataLength)', () => {
-        const header = createWavHeader(1000);
-        expect(header.readUInt32LE(4)).toBe(36 + 1000);
-    });
-    it('has PCM format (1)', () => {
-        const header = createWavHeader(1000);
-        expect(header.readUInt16LE(20)).toBe(1);
-    });
-    it('has correct data chunk size', () => {
-        const header = createWavHeader(2048);
-        expect(header.readUInt32LE(40)).toBe(2048);
-    });
-});
-describe('detectAudioFormat', () => {
-    it('detects MP3 with ID3 tag', () => {
-        const buf = Buffer.from([0x49, 0x44, 0x33, 0x00, 0x00]);
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'mp3', mimeType: 'audio/mpeg' });
-    });
-    it('detects MP3 frame sync (MPEG1 Layer3 = 0xFF 0xFB)', () => {
-        const buf = Buffer.from([0xff, 0xfb, 0x90, 0x00]);
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'mp3', mimeType: 'audio/mpeg' });
-    });
-    it('rejects reserved MP3 version bits (0x01)', () => {
-        // 0xFF 0xE8 → version bits = (0xE8 >> 3) & 0x03 = 0x01 (reserved)
-        const buf = Buffer.from([0xff, 0xe8, 0x00, 0x00]);
-        expect(detectAudioFormat(buf).ext).not.toBe('mp3');
-    });
-    it('detects WAV (RIFF...WAVE)', () => {
-        const buf = Buffer.alloc(12);
-        buf.write('RIFF', 0);
-        buf.writeUInt32LE(100, 4);
-        buf.write('WAVE', 8);
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'wav', mimeType: 'audio/wav' });
-    });
-    it('detects FLAC', () => {
-        const buf = Buffer.from('fLaC\x00\x00', 'ascii');
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'flac', mimeType: 'audio/flac' });
-    });
-    it('detects OGG', () => {
-        const buf = Buffer.from('OggS\x00\x00', 'ascii');
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'ogg', mimeType: 'audio/ogg' });
-    });
-    it('defaults to pcm for unknown data', () => {
-        const buf = Buffer.from([0x00, 0x01, 0x02, 0x03]);
-        expect(detectAudioFormat(buf)).toEqual({ ext: 'pcm', mimeType: 'audio/pcm' });
-    });
-    it('defaults to pcm for empty buffer', () => {
-        expect(detectAudioFormat(Buffer.alloc(0)).ext).toBe('pcm');
-    });
-});
-describe('wrapPcmInWav', () => {
-    it('prepends 44-byte WAV header', () => {
-        const pcm = Buffer.from([0x00, 0x01, 0x02, 0x03]);
-        const wav = wrapPcmInWav(pcm);
-        expect(wav.length).toBe(44 + 4);
-        expect(wav.subarray(0, 4).toString('ascii')).toBe('RIFF');
-        expect(wav.subarray(8, 12).toString('ascii')).toBe('WAVE');
-    });
-    it('detected as WAV after wrapping', () => {
-        const pcm = Buffer.alloc(100);
-        const wav = wrapPcmInWav(pcm);
-        expect(detectAudioFormat(wav)).toEqual({ ext: 'wav', mimeType: 'audio/wav' });
-    });
-});
-describe('replaceExtension', () => {
-    it('replaces existing extension', () => {
-        expect(replaceExtension('output.wav', 'mp3')).toBe('output.mp3');
-    });
-    it('appends extension when none exists', () => {
-        expect(replaceExtension('output', 'wav')).toBe('output.wav');
-    });
-    it('handles nested paths', () => {
-        expect(replaceExtension('/tmp/audio/file.wav', 'mp3')).toBe('/tmp/audio/file.mp3');
-    });
-    it('handles dotfiles', () => {
-        expect(replaceExtension('.hidden.wav', 'mp3')).toBe('.hidden.mp3');
-    });
-});

package/dist/__tests__/image-utils.test.d.ts

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