@stabgan/openrouter-mcp-multimodal 4.6.2 → 4.8.0

package/dist/tool-handlers/provider-routing.d.ts

@@ -5,6 +5,8 @@ export interface ProviderRoutingOptions {
     quantizations?: string[];
     /** Exclude these provider slugs (e.g. `['openai', 'anthropic']`). */
     ignore?: string[];
+    /** Allow only these provider slugs for the request. */
+    only?: string[];
     /** Sort providers by this criterion. */
     sort?: ProviderSort;
     /** Prioritized provider list (e.g. `['openai/gpt-4o', 'anthropic/claude-3-opus']`). */

package/dist/tool-handlers/provider-routing.js

@@ -66,6 +66,16 @@ export function readProviderDefaults() {
     const ignore = parseCsv(env.OPENROUTER_PROVIDER_IGNORE);
     if (ignore)
         out.ignore = ignore;
+    try {
+        const only = parseJsonArray(env.OPENROUTER_PROVIDER_ONLY, 'OPENROUTER_PROVIDER_ONLY');
+        if (only)
+            out.only = only;
+    }
+    catch (err) {
+        logger.warn('OPENROUTER_PROVIDER_ONLY ignored', {
+            err: err instanceof Error ? err.message : String(err),
+        });
+    }
     const sort = parseSort(env.OPENROUTER_PROVIDER_SORT);
     if (sort)
         out.sort = sort;

package/dist/tool-handlers/rerank.d.ts

@@ -11,7 +11,4 @@ export declare function handleRerankDocuments(request: {
     params: {
         arguments: RerankDocumentsRequest;
     };
-}, apiClient: OpenRouterAPIClient): Promise<import("../errors.js").ToolErrorResult | import("./structured-output.js").StructuredResult<{
-    model: string;
-    results: Record<string, unknown>[];
-}>>;
+}, apiClient: OpenRouterAPIClient): Promise<import("../errors.js").ToolErrorResult | import("./structured-output.js").StructuredResult<unknown>>;

package/dist/tool-handlers/rerank.js

@@ -1,7 +1,39 @@
 import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
 import { buildStructuredResult } from './structured-output.js';
+import { capResultText } from './completion-utils.js';
 const DEFAULT_MODEL = 'cohere/rerank-english-v3.0';
+function isValidDocumentIndex(index, documentCount) {
+    return (typeof index === 'number' && Number.isInteger(index) && index >= 0 && index < documentCount);
+}
+function normalizeRerankResults(response, documents, returnDocuments, modelFallback) {
+    const invalid = (response.results ?? []).find((r) => !isValidDocumentIndex(r.index, documents.length));
+    if (invalid) {
+        return toolError(ErrorCode.INTERNAL, `Rerank API returned invalid document index ${String(invalid.index)} (expected 0–${documents.length - 1}).`);
+    }
+    const normalized = (response.results ?? []).map((r) => {
+        const score = typeof r.score === 'number' ? r.score : r.relevance_score;
+        const out = { index: r.index, score };
+        if (returnDocuments) {
+            const rawDoc = typeof r.document === 'string' ? r.document : (r.document?.text ?? documents[r.index]);
+            const capped = capResultText(rawDoc);
+            out.document = capped.text;
+            if (capped.truncated)
+                out.document_truncated = true;
+        }
+        return out;
+    });
+    const payload = {
+        model: response.model ?? modelFallback,
+        results: normalized,
+    };
+    const jsonText = JSON.stringify(payload, null, 2);
+    const cappedJson = capResultText(jsonText);
+    if (cappedJson.truncated) {
+        return toolError(ErrorCode.RESOURCE_TOO_LARGE, 'Rerank result exceeds OPENROUTER_MAX_RESULT_TEXT_CHARS. Set it to 0 to disable or raise the limit.', { result_truncated: true });
+    }
+    return buildStructuredResult(payload, response.usage ? { usage: response.usage } : {});
+}
 export async function handleRerankDocuments(request, apiClient) {
     const args = request.params.arguments ?? { query: '', documents: [] };
     const { query, documents, model, top_n, return_documents } = args;
@@ -14,10 +46,19 @@ export async function handleRerankDocuments(request, apiClient) {
     if (documents.some((d) => typeof d !== 'string')) {
         return toolError(ErrorCode.INVALID_INPUT, 'every document must be a string.');
     }
+    if (top_n !== undefined) {
+        if (typeof top_n !== 'number' || !Number.isFinite(top_n)) {
+            return toolError(ErrorCode.INVALID_INPUT, 'top_n must be a finite number.');
+        }
+        if (top_n < 1) {
+            return toolError(ErrorCode.INVALID_INPUT, 'top_n must be at least 1 when specified.');
+        }
+    }
+    const effectiveModel = model || DEFAULT_MODEL;
     let response;
     try {
         response = await apiClient.rerank({
-            model: model || DEFAULT_MODEL,
+            model: effectiveModel,
             query,
             documents,
             top_n,
@@ -26,20 +67,8 @@ export async function handleRerankDocuments(request, apiClient) {
     catch (err) {
         return classifyUpstreamError(err, 'rerank');
     }
-    const normalized = (response.results ?? []).map((r) => {
-        const score = typeof r.score === 'number' ? r.score : r.relevance_score;
-        const out = { index: r.index, score };
-        if (return_documents) {
-            const doc = typeof r.document === 'string' ? r.document : (r.document?.text ?? documents[r.index]);
-            out.document = doc;
-        }
-        return out;
-    });
     try {
-        return buildStructuredResult({
-            model: response.model ?? model ?? DEFAULT_MODEL,
-            results: normalized,
-        }, response.usage ? { usage: response.usage } : {});
+        return normalizeRerankResults(response, documents, return_documents === true, effectiveModel);
     }
     catch (err) {
         return toolErrorFrom(ErrorCode.INTERNAL, err, 'rerank');

package/dist/tool-handlers/search-models.js

@@ -1,8 +1,8 @@
+import { clampLimit, clampOffset } from '../model-cache.js';
 import { ErrorCode, toolErrorFrom } from '../errors.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
 import { buildStructuredResult } from './structured-output.js';
 const DEFAULT_LIMIT = 20;
-const MAX_LIMIT = 50;
 export async function handleSearchModels(request, apiClient, modelCache) {
     try {
         await modelCache.ensureFresh(() => apiClient.getModels());
@@ -12,8 +12,8 @@ export async function handleSearchModels(request, apiClient, modelCache) {
     }
     try {
         const args = request.params.arguments ?? {};
-        const limit = Math.min(Math.max(1, args.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
-        const offset = Math.max(0, args.offset ?? 0);
+        const limit = clampLimit(args.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
+        const offset = clampOffset(args.offset ?? 0);
         const { page, total } = modelCache.searchPaginated({
             query: args.query,
             provider: args.provider,

package/dist/tool-handlers/speech-to-text.d.ts

@@ -1,3 +1,4 @@
+/** Dedicated POST /api/v1/audio/transcriptions — Whisper, GPT-4o Transcribe, Voxtral. */
 import type { OpenRouterAPIClient } from '../openrouter-api.js';
 import { type CacheOptions } from './cache.js';
 export interface SpeechToTextRequest extends CacheOptions {

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

@@ -1,63 +1,18 @@
-/** Dedicated POST /api/v1/audio/transcriptions — Whisper, GPT-4o Transcribe, Voxtral. */
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { resolveSafeInputPath, UnsafeOutputPathError } from './path-safety.js';
-import { fetchHttpResource } from './fetch-utils.js';
+import { STT_RESPONSE_FORMATS } from '../tool-definitions.js';
+import { UnsafeOutputPathError } from './path-safety.js';
+import { resolveSpeechToTextAudio } from './audio-utils.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 { buildCacheHeaders } from './cache.js';
+import { buildCacheHeaders, validateCacheOptions } from './cache.js';
 const DEFAULT_MODEL = 'openai/whisper-1';
-const VALID_RESPONSE_FORMATS = new Set(['json', 'text', 'srt', 'verbose_json', 'vtt']);
-/** Infer audio format from file extension. */
-function audioFormatFromExt(ext) {
-    const normalized = ext.toLowerCase().replace('.', '');
-    switch (normalized) {
-        case 'mp3':
-            return 'mp3';
-        case 'mp4':
-        case 'm4a':
-            return 'mp4';
-        case 'wav':
-            return 'wav';
-        case 'flac':
-            return 'flac';
-        case 'ogg':
-        case 'oga':
-            return 'ogg';
-        case 'webm':
-            return 'webm';
-        case 'opus':
-            return 'opus';
-        default:
-            return 'mp3';
+const VALID_RESPONSE_FORMATS = new Set(STT_RESPONSE_FORMATS);
+function formatTranscriptionContent(response, responseFormat) {
+    if (responseFormat === 'verbose_json') {
+        return JSON.stringify(response, null, 2);
     }
-}
-async function resolveAudioInput(audioPath) {
-    const trimmed = audioPath.trim();
-    if (!trimmed)
-        throw new Error('audio_path is empty');
-    if (trimmed.startsWith('data:')) {
-        const match = trimmed.match(/^data:audio\/([^;,]+)(?:;[^,]*)*;base64,(.+)$/);
-        if (!match)
-            throw new Error('Invalid audio data URL format');
-        return { data: match[2], format: match[1] };
-    }
-    if (/^https?:\/\//i.test(trimmed)) {
-        const { buffer, contentType } = await fetchHttpResource(trimmed, {
-            timeoutMs: 60_000,
-            maxBytes: 100 * 1024 * 1024,
-            maxRedirects: 8,
-        });
-        const format = contentType?.match(/audio\/(\w+)/)?.[1] || 'mp3';
-        return { data: buffer.toString('base64'), format };
-    }
-    const abs = await resolveSafeInputPath(trimmed);
-    const buf = await fs.readFile(abs);
-    const ext = path.extname(abs);
-    const format = audioFormatFromExt(ext);
-    return { data: buf.toString('base64'), format };
+    return response.text ?? null;
 }
 export async function handleSpeechToText(request, apiClient) {
     const args = request.params.arguments ?? {};
@@ -68,6 +23,12 @@ export async function handleSpeechToText(request, apiClient) {
     if (response_format && !VALID_RESPONSE_FORMATS.has(response_format)) {
         return toolError(ErrorCode.INVALID_INPUT, `response_format '${response_format}' is not supported. Valid: ${[...VALID_RESPONSE_FORMATS].join(', ')}.`);
     }
+    if (typeof temperature === 'number' && (temperature < 0 || temperature > 1)) {
+        return toolError(ErrorCode.INVALID_INPUT, 'temperature must be between 0 and 1 (inclusive).');
+    }
+    const cacheError = validateCacheOptions({ cache, cache_ttl, cache_clear });
+    if (cacheError)
+        return cacheError;
     logger.audit('speech_to_text.start', {
         model: model || DEFAULT_MODEL,
         audio_path: audio_path.startsWith('data:') ? 'data_url' : audio_path.slice(0, 80),
@@ -76,7 +37,7 @@ export async function handleSpeechToText(request, apiClient) {
     });
     let audioInput;
     try {
-        audioInput = await resolveAudioInput(audio_path);
+        audioInput = await resolveSpeechToTextAudio(audio_path);
     }
     catch (err) {
         if (err instanceof UnsafeOutputPathError)
@@ -84,6 +45,12 @@ export async function handleSpeechToText(request, apiClient) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg.includes('Blocked host'))
             return toolErrorFrom(ErrorCode.UPSTREAM_REFUSED, err);
+        if (msg.toLowerCase().includes('too large')) {
+            return toolErrorFrom(ErrorCode.RESOURCE_TOO_LARGE, err);
+        }
+        if (msg.toLowerCase().includes('unsupported')) {
+            return toolErrorFrom(ErrorCode.UNSUPPORTED_FORMAT, err);
+        }
         return toolErrorFrom(ErrorCode.INVALID_INPUT, err);
     }
     const body = {
@@ -107,7 +74,7 @@ export async function handleSpeechToText(request, apiClient) {
     catch (err) {
         return classifyUpstreamError(err, 'speech_to_text');
     }
-    const text = response.text;
+    const text = formatTranscriptionContent(response, response_format);
     if (!text) {
         return toolError(ErrorCode.INTERNAL, 'Transcription returned no text.', {
             response_keys: Object.keys(response),

package/dist/tool-handlers/text-to-speech.d.ts

@@ -13,17 +13,7 @@ export declare function handleTextToSpeech(request: {
     params: {
         arguments: TextToSpeechRequest;
     };
-}, apiClient: OpenRouterAPIClient): Promise<import("../errors.js").ToolErrorResult | {
-    content: ({
-        type: "text";
-        text: string;
-        mimeType?: undefined;
-        data?: undefined;
-    } | {
-        type: "audio";
-        mimeType: string;
-        data: string;
-        text?: undefined;
-    })[];
+}, apiClient: OpenRouterAPIClient): Promise<{
+    content: import("./tool-result-payload.js").BinaryToolContent[];
     _meta: Record<string, unknown>;
 }>;

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

@@ -1,15 +1,20 @@
 /** Dedicated POST /api/v1/audio/speech — OpenAI, Gemini Flash TTS, Voxtral. */
-import { promises as fs } from 'node:fs';
 import { extname } from 'node:path';
+import { TTS_RESPONSE_FORMATS } from '../tool-definitions.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 { buildCacheHeaders } from './cache.js';
+import { buildBinaryToolResult } from './tool-result-payload.js';
+import { replaceExtension, writeOutputFile } from './path-utils.js';
+import { buildCacheHeaders, validateCacheOptions } from './cache.js';
+import { detectAudioFormat } from './audio-utils.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']);
+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;
@@ -19,6 +24,12 @@ 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;
     logger.audit('text_to_speech.start', {
         model: model || DEFAULT_MODEL,
         voice: voice || DEFAULT_VOICE,
@@ -37,7 +48,7 @@ export async function handleTextToSpeech(request, apiClient) {
     };
     if (response_format)
         body.response_format = response_format;
-    if (typeof speed === 'number' && speed > 0)
+    if (typeof speed === 'number')
         body.speed = speed;
     if (instructions)
         body.instructions = instructions;
@@ -50,8 +61,9 @@ 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,
@@ -61,27 +73,22 @@ export async function handleTextToSpeech(request, apiClient) {
     };
     if (safeSavePath) {
         const currentExt = extname(safeSavePath).toLowerCase().slice(1);
-        const actualPath = currentExt === ext ? safeSavePath : `${safeSavePath}.${ext}`;
+        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');
         }
         baseMeta.save_path = actualPath;
-        return {
-            content: [
-                { type: 'text', text: `Speech saved to: ${actualPath}` },
-                { type: 'audio', mimeType, data: buffer.toString('base64') },
-            ],
-            _meta: baseMeta,
-        };
+        return buildBinaryToolResult({ kind: 'audio', buffer, mimeType }, {
+            savedPath: actualPath,
+            summaryText: `Speech saved to: ${actualPath}`,
+            meta: baseMeta,
+        });
     }
-    return {
-        content: [
-            { type: 'text', text: `Speech generated (${buffer.length} bytes, ${mimeType}).` },
-            { type: 'audio', mimeType, data: buffer.toString('base64') },
-        ],
-        _meta: baseMeta,
-    };
+    return buildBinaryToolResult({ kind: 'audio', buffer, mimeType }, {
+        prefixText: `Speech generated (${buffer.length} bytes, ${mimeType}).`,
+        meta: baseMeta,
+    });
 }

package/dist/tool-handlers/tool-result-payload.d.ts

@@ -0,0 +1,47 @@
+export type InlineMediaKind = 'image' | 'audio' | 'video';
+type TextContent = {
+    type: 'text';
+    text: string;
+};
+type ImageContent = {
+    type: 'image';
+    mimeType: string;
+    data: string;
+};
+type AudioContent = {
+    type: 'audio';
+    mimeType: string;
+    data: string;
+};
+type ResourceContent = {
+    type: 'resource';
+    resource: {
+        uri: string;
+        mimeType?: string;
+        blob: string;
+    };
+};
+export type BinaryToolContent = TextContent | ImageContent | AudioContent | ResourceContent;
+export interface BinaryArtifact {
+    kind: InlineMediaKind;
+    buffer: Buffer;
+    mimeType: string;
+}
+export interface BuildBinaryToolResultOptions {
+    savedPath?: string | null;
+    /** Overrides default saved/too-large message */
+    summaryText?: string;
+    /** Shown alongside inline media when not using inlineOnly */
+    prefixText?: string;
+    /** When inline fits and no save_path: return media block only (image UX) */
+    inlineOnly?: boolean;
+    remoteUrl?: string;
+    meta?: Record<string, unknown>;
+    maxInlineBytes?: number;
+}
+export declare function getMaxInlineBytes(kind: InlineMediaKind): number;
+export declare function buildBinaryToolResult(artifact: BinaryArtifact, opts?: BuildBinaryToolResultOptions): {
+    content: BinaryToolContent[];
+    _meta: Record<string, unknown>;
+};
+export {};

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

@@ -0,0 +1,98 @@
+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';
+const KIND_ENV_KEYS = {
+    image: 'OPENROUTER_IMAGE_INLINE_MAX_BYTES',
+    audio: 'OPENROUTER_AUDIO_INLINE_MAX_BYTES',
+    video: 'OPENROUTER_VIDEO_INLINE_MAX_BYTES',
+};
+const KIND_DEFAULT_BYTES = {
+    image: DEFAULT_INLINE_MAX_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 = readEnvInlineMaxBytes('OPENROUTER_INLINE_MAX_BYTES', KIND_DEFAULT_BYTES[kind]);
+    return readEnvInlineMaxBytes(KIND_ENV_KEYS[kind], globalFallback);
+}
+function kindLabel(kind) {
+    switch (kind) {
+        case 'image':
+            return 'Image';
+        case 'audio':
+            return 'Audio';
+        case 'video':
+            return 'Video';
+        default: {
+            const _exhaustive = kind;
+            return _exhaustive;
+        }
+    }
+}
+function buildInlineBlock(kind, mimeType, data, remoteUrl) {
+    if (kind === 'video') {
+        return {
+            type: 'resource',
+            resource: {
+                uri: remoteUrl ?? INLINE_VIDEO_URI,
+                mimeType,
+                blob: data,
+            },
+        };
+    }
+    return { type: kind, mimeType, data };
+}
+export function buildBinaryToolResult(artifact, opts = {}) {
+    const { kind, buffer, mimeType } = artifact;
+    const maxInline = opts.maxInlineBytes ?? getMaxInlineBytes(kind);
+    const meta = {
+        ...opts.meta,
+        mime: mimeType,
+        size_bytes: buffer.length,
+    };
+    if (opts.savedPath) {
+        const text = opts.summaryText ??
+            `${kindLabel(kind)} saved to: ${opts.savedPath} (${buffer.length} bytes, ${mimeType})`;
+        return {
+            content: [{ type: 'text', text }],
+            _meta: { ...meta, save_path: opts.savedPath },
+        };
+    }
+    if (buffer.length <= maxInline) {
+        const data = buffer.toString('base64');
+        if (opts.inlineOnly) {
+            return {
+                content: [buildInlineBlock(kind, mimeType, data, opts.remoteUrl)],
+                _meta: meta,
+            };
+        }
+        const text = opts.prefixText ?? `${kindLabel(kind)} generated (${buffer.length} bytes, ${mimeType}).`;
+        return {
+            content: [textBlock(text), buildInlineBlock(kind, mimeType, data, opts.remoteUrl)],
+            _meta: meta,
+        };
+    }
+    const urlHint = opts.remoteUrl ? ` URL: ${opts.remoteUrl}` : '';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: opts.summaryText ??
+                    `${kindLabel(kind)} generated (${buffer.length} bytes, ${mimeType}). Too large to inline; pass save_path to persist.${urlHint}`,
+            },
+        ],
+        _meta: meta,
+    };
+}
+function textBlock(text) {
+    return { type: 'text', text };
+}

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

@@ -1,5 +1,5 @@
 import { CallToolRequestSchema, ErrorCode as McpErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import OpenAI from 'openai';
+import { createOpenRouterOpenAIClient } from './openrouter-openai-client.js';
 import { ModelCache } from './model-cache.js';
 import { OpenRouterAPIClient } from './openrouter-api.js';
 import { handleChatCompletion } from './tool-handlers/chat-completion.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) });
         });
     };
 }
@@ -55,10 +61,7 @@ export class ToolHandlers {
     constructor(server, apiKey, defaultModel) {
         this.defaultModel = defaultModel;
         this.apiClient = new OpenRouterAPIClient(apiKey);
-        this.openai = new OpenAI({
-            apiKey,
-            baseURL: 'https://openrouter.ai/api/v1',
-        });
+        this.openai = createOpenRouterOpenAIClient(apiKey);
         this.server = server;
         this.register(server);
     }
@@ -71,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':
@@ -116,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/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SERVER_VERSION = "4.6.2";
+export declare const SERVER_VERSION = "4.8.0";
 export declare const MCP_PROTOCOL_VERSION = "2025-06-18";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const SERVER_VERSION = '4.6.2';
+export const SERVER_VERSION = '4.8.0';
 export const MCP_PROTOCOL_VERSION = '2025-06-18';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stabgan/openrouter-mcp-multimodal",
-  "version": "4.6.2",
+  "version": "4.8.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",
@@ -68,8 +68,6 @@
     "@types/node": "^22.20.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "form-data": "^4.0.6",
-    "js-yaml": "^4.3.0",
     "prettier": "^3.9.4",
     "shx": "^0.4.0",
     "typescript": "^5.9.3",