@stabgan/openrouter-mcp-multimodal 4.7.0 → 5.0.0

package/dist/tool-handlers/text-to-speech.js

@@ -1,17 +1,19 @@
-/** Dedicated POST /api/v1/audio/speech — OpenAI, Gemini Flash TTS, Voxtral. */
-import { promises as fs } from 'node:fs';
+/** Dedicated POST /api/v1/audio/speech. */
 import { extname } from 'node:path';
+import { TTS_RESPONSE_FORMATS } from '../tool-definitions.js';
+import { DEFAULT_TTS_MODEL, DEFAULT_TTS_RESPONSE_FORMAT, DEFAULT_TTS_VOICE, } from '../tts-defaults.js';
 import { resolveOptionalOutputPath, isToolErrorResult } from './path-safety.js';
 import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 import { SERVER_VERSION } from '../version.js';
 import { logger } from '../logger.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
 import { buildBinaryToolResult } from './tool-result-payload.js';
-import { replaceExtension } from './path-utils.js';
-import { buildCacheHeaders } from './cache.js';
-const DEFAULT_MODEL = 'openai/gpt-4o-mini-tts-2025-12-15';
-const DEFAULT_VOICE = 'alloy';
-const VALID_FORMATS = new Set(['mp3', 'opus', 'aac', 'flac', 'wav', 'pcm']);
+import { replaceExtension, writeOutputFile } from './path-utils.js';
+import { buildCacheHeaders, validateCacheOptions } from './cache.js';
+import { detectAudioFormat } from './audio-utils.js';
+const MIN_SPEED = 0.25;
+const MAX_SPEED = 4.0;
+const VALID_FORMATS = new Set(TTS_RESPONSE_FORMATS);
 export async function handleTextToSpeech(request, apiClient) {
     const args = request.params.arguments ?? {};
     const { input, model, voice, response_format, speed, instructions, save_path, cache, cache_ttl, cache_clear, } = args;
@@ -21,10 +23,19 @@ export async function handleTextToSpeech(request, apiClient) {
     if (response_format && !VALID_FORMATS.has(response_format)) {
         return toolError(ErrorCode.INVALID_INPUT, `response_format '${response_format}' is not supported. Valid: ${[...VALID_FORMATS].join(', ')}.`);
     }
+    if (typeof speed === 'number' && (speed < MIN_SPEED || speed > MAX_SPEED)) {
+        return toolError(ErrorCode.INVALID_INPUT, `speed must be between ${MIN_SPEED} and ${MAX_SPEED} (inclusive).`);
+    }
+    const cacheError = validateCacheOptions({ cache, cache_ttl, cache_clear });
+    if (cacheError)
+        return cacheError;
+    const effectiveModel = model?.trim() || DEFAULT_TTS_MODEL;
+    const effectiveVoice = voice?.trim() || (effectiveModel === DEFAULT_TTS_MODEL ? DEFAULT_TTS_VOICE : undefined);
+    const effectiveResponseFormat = response_format || DEFAULT_TTS_RESPONSE_FORMAT;
     logger.audit('text_to_speech.start', {
-        model: model || DEFAULT_MODEL,
-        voice: voice || DEFAULT_VOICE,
-        response_format: response_format || 'mp3',
+        model: effectiveModel,
+        voice: effectiveVoice || 'provider default',
+        response_format: effectiveResponseFormat,
         input_preview: input.slice(0, 80),
         save_path: save_path ? 'provided' : 'none',
     });
@@ -33,13 +44,13 @@ export async function handleTextToSpeech(request, apiClient) {
         return savePathResult;
     const safeSavePath = savePathResult.path;
     const body = {
-        model: model || DEFAULT_MODEL,
+        model: effectiveModel,
         input,
-        voice: voice || DEFAULT_VOICE,
+        response_format: effectiveResponseFormat,
     };
-    if (response_format)
-        body.response_format = response_format;
-    if (typeof speed === 'number' && speed > 0)
+    if (effectiveVoice)
+        body.voice = effectiveVoice;
+    if (typeof speed === 'number')
         body.speed = speed;
     if (instructions)
         body.instructions = instructions;
@@ -52,20 +63,22 @@ export async function handleTextToSpeech(request, apiClient) {
         return classifyUpstreamError(err, 'text_to_speech');
     }
     const { buffer, contentType } = result;
-    const mimeType = contentType.split(';')[0]?.trim() || 'audio/mpeg';
-    const ext = response_format || 'mp3';
+    const detected = detectAudioFormat(buffer);
+    const mimeType = detected.mimeType || contentType.split(';')[0]?.trim() || 'audio/mpeg';
+    const ext = detected.ext;
     const baseMeta = {
         server_version: SERVER_VERSION,
-        model: model || DEFAULT_MODEL,
+        model: effectiveModel,
         mime: mimeType,
         size_bytes: buffer.length,
-        voice: voice || DEFAULT_VOICE,
     };
+    if (effectiveVoice)
+        baseMeta.voice = effectiveVoice;
     if (safeSavePath) {
         const currentExt = extname(safeSavePath).toLowerCase().slice(1);
         const actualPath = currentExt === ext ? safeSavePath : replaceExtension(safeSavePath, ext);
         try {
-            await fs.writeFile(actualPath, buffer);
+            await writeOutputFile(actualPath, buffer);
         }
         catch (err) {
             return toolErrorFrom(ErrorCode.INTERNAL, err, 'Write');

package/dist/tool-handlers/tool-result-payload.js

@@ -1,10 +1,3 @@
-/**
- * Canonical MCP tool-result policy for binary artifacts:
- * - saved to disk -> text pointer only (never duplicate inline media)
- * - not saved -> inline only when under byte ceiling, else text + save_path hint
- * - video uses MCP `resource` blocks (spec has no `video` content type)
- */
-import { readEnvInt } from './fetch-utils.js';
 const DEFAULT_INLINE_MAX_BYTES = 1024 * 1024;
 const DEFAULT_VIDEO_INLINE_MAX_BYTES = 10 * 1024 * 1024;
 const INLINE_VIDEO_URI = 'inline://openrouter-mcp-multimodal/video';
@@ -18,9 +11,18 @@ const KIND_DEFAULT_BYTES = {
     audio: DEFAULT_INLINE_MAX_BYTES,
     video: DEFAULT_VIDEO_INLINE_MAX_BYTES,
 };
+function readEnvInlineMaxBytes(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === '')
+        return fallback;
+    if (!/^\d+$/.test(raw))
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
 export function getMaxInlineBytes(kind) {
-    const globalFallback = readEnvInt('OPENROUTER_INLINE_MAX_BYTES', KIND_DEFAULT_BYTES[kind], 4096);
-    return readEnvInt(KIND_ENV_KEYS[kind], globalFallback, 4096);
+    const globalFallback = readEnvInlineMaxBytes('OPENROUTER_INLINE_MAX_BYTES', KIND_DEFAULT_BYTES[kind]);
+    return readEnvInlineMaxBytes(KIND_ENV_KEYS[kind], globalFallback);
 }
 function kindLabel(kind) {
     switch (kind) {

package/dist/tool-handlers/validate-model.js

@@ -17,6 +17,6 @@ export async function handleValidateModel(request, modelCache, apiClient) {
     if (!modelCache.isValid()) {
         return toolError(ErrorCode.INTERNAL, 'No model data available.');
     }
-    const valid = modelCache.has(model);
+    const valid = modelCache.catalogHas(model);
     return buildStructuredResult({ valid, model });
 }

package/dist/tool-handlers.d.ts

@@ -1,4 +1,12 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+type McpProgressHook = (update: {
+    status: string;
+    progress?: number;
+    attempt: number;
+    video_id: string;
+}) => void;
+/** MCP `notifications/progress` hook. */
+export declare function buildProgressHook(server: Server, progressToken: string | number | undefined): McpProgressHook | undefined;
 export declare class ToolHandlers {
     private openai;
     private modelCache;
@@ -8,3 +16,4 @@ export declare class ToolHandlers {
     constructor(server: Server, apiKey: string, defaultModel?: string);
     private register;
 }
+export {};

package/dist/tool-handlers.js

@@ -20,25 +20,31 @@ import { handleSpeechToText } from './tool-handlers/speech-to-text.js';
 import { handleStartChatCompletion, handleGetChatCompletionStatus, } from './tool-handlers/async-chat.js';
 import { TOOL_DEFINITIONS } from './tool-definitions.js';
 import { TOOL_ICONS } from './tool-icons.js';
+import { ErrorCode, toolErrorFrom } from './errors.js';
+import { logger } from './logger.js';
 function wrapToolArgs(a) {
     return { params: { arguments: a ?? {} } };
 }
-function buildProgressHook(server, progressToken) {
+/** MCP `notifications/progress` hook. */
+export function buildProgressHook(server, progressToken) {
     if (progressToken === undefined)
         return undefined;
-    // MCP progress must monotonically increase; upstream values can drop or be omitted.
     let lastSent = -1;
     return ({ status, progress, attempt, video_id }) => {
         const candidate = typeof progress === 'number' ? Math.max(attempt, progress) : attempt;
         const next = Math.max(lastSent + 1, candidate);
         lastSent = next;
-        void server.notification({
+        void server
+            .notification({
             method: 'notifications/progress',
             params: {
                 progressToken,
                 progress: next,
                 message: `video ${video_id} — ${status}${typeof progress === 'number' ? ` (${progress}%)` : ''}`,
             },
+        })
+            .catch((err) => {
+            logger.warn('progress notification failed', { err: String(err) });
         });
     };
 }
@@ -68,7 +74,6 @@ export class ToolHandlers {
         }));
         server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
-            // Handlers return extra _meta keys not in the SDK type.
             const dispatch = async () => {
                 switch (name) {
                     case 'chat_completion':
@@ -113,7 +118,14 @@ export class ToolHandlers {
                         throw new McpError(McpErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
             };
-            return (await dispatch());
+            try {
+                return (await dispatch());
+            }
+            catch (err) {
+                if (err instanceof McpError)
+                    throw err;
+                return toolErrorFrom(ErrorCode.INTERNAL, err);
+            }
         });
     }
 }

package/dist/tts-defaults.d.ts

@@ -0,0 +1,4 @@
+/** Current free OpenRouter TTS defaults; model and voice can be overridden per call. */
+export declare const DEFAULT_TTS_MODEL = "deepgram/flux-tts:free";
+export declare const DEFAULT_TTS_VOICE = "flux-alexis-en";
+export declare const DEFAULT_TTS_RESPONSE_FORMAT = "mp3";

package/dist/tts-defaults.js

@@ -0,0 +1,4 @@
+/** Current free OpenRouter TTS defaults; model and voice can be overridden per call. */
+export const DEFAULT_TTS_MODEL = 'deepgram/flux-tts:free';
+export const DEFAULT_TTS_VOICE = 'flux-alexis-en';
+export const DEFAULT_TTS_RESPONSE_FORMAT = 'mp3';

package/dist/version.d.ts

@@ -1,2 +1,3 @@
-export declare const SERVER_VERSION = "4.7.0";
-export declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+export declare const SERVER_VERSION = "5.0.0";
+/** Advertised MCP protocol version — derived from the installed SDK. */
+export declare const MCP_PROTOCOL_VERSION = "2025-11-25";

package/dist/version.js

@@ -1,2 +1,4 @@
-export const SERVER_VERSION = '4.7.0';
-export const MCP_PROTOCOL_VERSION = '2025-06-18';
+import { LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/sdk/types.js';
+export const SERVER_VERSION = '5.0.0';
+/** Advertised MCP protocol version — derived from the installed SDK. */
+export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stabgan/openrouter-mcp-multimodal",
-  "version": "4.7.0",
+  "version": "5.0.0",
   "mcpName": "io.github.stabgan/openrouter-multimodal",
   "description": "MCP server for OpenRouter — chat with 300+ LLMs, analyze images/audio/video, generate images (dedicated API), TTS/STT, video generation (Veo 3.1 / Seedance / Wan), async completions, response caching",
   "type": "module",
@@ -55,25 +55,23 @@
   "homepage": "https://github.com/stabgan/openrouter-mcp-multimodal#readme",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "dotenv": "^17.4.2",
-    "openai": "^4.104.0",
-    "sharp": "^0.35.3"
+    "openai": "^7.9.0",
+    "sharp": "^0.35.4"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@types/node": "^22.20.0",
-    "eslint": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.20.1",
+    "eslint": "^10.9.1",
     "eslint-config-prettier": "^10.1.8",
-    "form-data": "^4.0.6",
-    "js-yaml": "^4.3.0",
-    "prettier": "^3.9.4",
+    "prettier": "^3.9.6",
     "shx": "^0.4.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.62.1",
-    "vitest": "^4.1.9"
+    "typescript-eslint": "^8.69.0",
+    "vitest": "^4.1.11"
   }
 }