@stabgan/openrouter-mcp-multimodal 1.5.0 → 1.8.0

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;
 }>;

package/dist/tool-handlers/analyze-image.js

@@ -1,335 +1,28 @@
-import path from 'path';
-import { promises as fs } from 'fs';
-import fetch from 'node-fetch';
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { findSuitableFreeModel } from './multi-image-analysis.js';
-// Default model for image analysis
-const DEFAULT_FREE_MODEL = 'qwen/qwen2.5-vl-32b-instruct:free';
-let sharp;
-try {
-    sharp = require('sharp');
-}
-catch (e) {
-    console.error('Warning: sharp module not available, using fallback image processing');
-    // Mock implementation that just passes through the base64 data
-    sharp = (buffer) => ({
-        metadata: async () => ({ width: 800, height: 600 }),
-        resize: () => ({
-            jpeg: () => ({
-                toBuffer: async () => buffer
-            })
-        }),
-        jpeg: () => ({
-            toBuffer: async () => buffer
-        })
-    });
-}
-/**
- * Normalizes a file path to be OS-neutral
- * Handles Windows backslashes, drive letters, etc.
- */
-function normalizePath(filePath) {
-    // Skip normalization for URLs and data URLs
-    if (filePath.startsWith('http://') ||
-        filePath.startsWith('https://') ||
-        filePath.startsWith('data:')) {
-        return filePath;
-    }
-    // Handle Windows paths and convert them to a format that's usable
-    // First normalize the path according to the OS
-    let normalized = path.normalize(filePath);
-    // Make sure any Windows backslashes are handled
-    normalized = normalized.replace(/\\/g, '/');
-    return normalized;
-}
-async function fetchImageAsBuffer(url) {
-    try {
-        // Handle data URLs
-        if (url.startsWith('data:')) {
-            const matches = url.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
-            if (!matches || matches.length !== 3) {
-                throw new Error('Invalid data URL');
-            }
-            return Buffer.from(matches[2], 'base64');
-        }
-        // Normalize the path before proceeding
-        const normalizedUrl = normalizePath(url);
-        // Handle file URLs
-        if (normalizedUrl.startsWith('file://')) {
-            const filePath = normalizedUrl.replace('file://', '');
-            return await fs.readFile(filePath);
-        }
-        // Handle http/https URLs
-        if (normalizedUrl.startsWith('http://') || normalizedUrl.startsWith('https://')) {
-            const response = await fetch(normalizedUrl);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            return Buffer.from(await response.arrayBuffer());
-        }
-        // Handle regular file paths
-        try {
-            return await fs.readFile(normalizedUrl);
-        }
-        catch (error) {
-            // Try the original path as a fallback
-            if (normalizedUrl !== url) {
-                try {
-                    return await fs.readFile(url);
-                }
-                catch (secondError) {
-                    console.error(`Failed to read file with normalized path (${normalizedUrl}) and original path (${url})`);
-                    throw error; // Throw the original error
-                }
-            }
-            throw error;
-        }
-    }
-    catch (error) {
-        console.error(`Error fetching image from ${url}:`, error);
-        throw error;
-    }
-}
-/**
- * Processes an image with minimal processing when sharp isn't available
- */
-async function processImageFallback(buffer) {
-    try {
-        // Just return the buffer as base64 without processing
-        return buffer.toString('base64');
-    }
-    catch (error) {
-        console.error('Error in fallback image processing:', error);
-        throw error;
-    }
-}
-async function processImage(buffer) {
-    try {
-        if (typeof sharp !== 'function') {
-            console.warn('Using fallback image processing (sharp not available)');
-            return processImageFallback(buffer);
-        }
-        // Get image metadata
-        let metadata;
-        try {
-            metadata = await sharp(buffer).metadata();
-        }
-        catch (error) {
-            console.warn('Error getting image metadata, using fallback:', error);
-            return processImageFallback(buffer);
-        }
-        // Calculate dimensions to keep base64 size reasonable
-        const MAX_DIMENSION = 800;
-        const JPEG_QUALITY = 80;
-        if (metadata.width && metadata.height) {
-            const largerDimension = Math.max(metadata.width, metadata.height);
-            if (largerDimension > MAX_DIMENSION) {
-                const resizeOptions = metadata.width > metadata.height
-                    ? { width: MAX_DIMENSION }
-                    : { height: MAX_DIMENSION };
-                const resizedBuffer = await sharp(buffer)
-                    .resize(resizeOptions)
-                    .jpeg({ quality: JPEG_QUALITY })
-                    .toBuffer();
-                return resizedBuffer.toString('base64');
-            }
-        }
-        // If no resizing needed, just convert to JPEG
-        const jpegBuffer = await sharp(buffer)
-            .jpeg({ quality: JPEG_QUALITY })
-            .toBuffer();
-        return jpegBuffer.toString('base64');
-    }
-    catch (error) {
-        console.error('Error processing image, using fallback:', error);
-        return processImageFallback(buffer);
-    }
-}
-/**
- * Processes an image from a path or base64 string to a proper base64 format for APIs
- */
-async function prepareImage(imagePath) {
-    try {
-        // Check if already a base64 data URL
-        if (imagePath.startsWith('data:')) {
-            const matches = imagePath.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
-            if (!matches || matches.length !== 3) {
-                throw new McpError(ErrorCode.InvalidParams, 'Invalid base64 data URL format');
-            }
-            return { base64: matches[2], mimeType: matches[1] };
-        }
-        // Normalize the path first
-        const normalizedPath = normalizePath(imagePath);
-        // Check if image is a URL
-        if (normalizedPath.startsWith('http://') || normalizedPath.startsWith('https://')) {
-            try {
-                const buffer = await fetchImageAsBuffer(normalizedPath);
-                const processed = await processImage(buffer);
-                return { base64: processed, mimeType: 'image/jpeg' }; // We convert everything to JPEG
-            }
-            catch (error) {
-                throw new McpError(ErrorCode.InvalidParams, `Failed to fetch image from URL: ${error.message}`);
-            }
-        }
-        // Handle file paths
-        let absolutePath = normalizedPath;
-        // For local file paths, ensure they are absolute 
-        // Don't check URLs or data URIs
-        if (!normalizedPath.startsWith('data:') &&
-            !normalizedPath.startsWith('http://') &&
-            !normalizedPath.startsWith('https://')) {
-            if (!path.isAbsolute(normalizedPath)) {
-                throw new McpError(ErrorCode.InvalidParams, 'Image path must be absolute');
-            }
-            // For Windows paths that include a drive letter but aren't recognized as absolute
-            // by path.isAbsolute in some environments
-            if (/^[A-Za-z]:/.test(normalizedPath) && !path.isAbsolute(normalizedPath)) {
-                absolutePath = path.resolve(normalizedPath);
-            }
-        }
-        try {
-            // Check if the file exists
-            await fs.access(absolutePath);
-        }
-        catch (error) {
-            // Try the original path as a fallback
-            try {
-                await fs.access(imagePath);
-                absolutePath = imagePath; // Use the original path if that works
-            }
-            catch (secondError) {
-                throw new McpError(ErrorCode.InvalidParams, `File not found: ${absolutePath}`);
-            }
-        }
-        // Read the file as a buffer
-        let buffer;
-        try {
-            buffer = await fs.readFile(absolutePath);
-        }
-        catch (error) {
-            // Try the original path as a fallback
-            try {
-                buffer = await fs.readFile(imagePath);
-            }
-            catch (secondError) {
-                throw new McpError(ErrorCode.InvalidParams, `Failed to read file: ${absolutePath}`);
-            }
-        }
-        // Determine MIME type from file extension
-        const extension = path.extname(absolutePath).toLowerCase();
-        let mimeType;
-        switch (extension) {
-            case '.png':
-                mimeType = 'image/png';
-                break;
-            case '.jpg':
-            case '.jpeg':
-                mimeType = 'image/jpeg';
-                break;
-            case '.webp':
-                mimeType = 'image/webp';
-                break;
-            case '.gif':
-                mimeType = 'image/gif';
-                break;
-            case '.bmp':
-                mimeType = 'image/bmp';
-                break;
-            default:
-                mimeType = 'application/octet-stream';
-        }
-        // Process and optimize the image
-        const processed = await processImage(buffer);
-        return { base64: processed, mimeType };
-    }
-    catch (error) {
-        console.error('Error preparing image:', error);
-        throw error;
-    }
-}
-/**
- * Handler for analyzing a single image
- */
+import { prepareImageUrl } from './image-utils.js';
+const DEFAULT_MODEL = 'nvidia/nemotron-nano-12b-v2-vl:free';
 export async function handleAnalyzeImage(request, openai, defaultModel) {
-    const args = request.params.arguments;
+    const { image_path, question, model } = request.params.arguments;
+    if (!image_path) {
+        return { content: [{ type: 'text', text: 'image_path is required.' }], isError: true };
+    }
     try {
-        // Validate inputs
-        if (!args.image_path) {
-            throw new McpError(ErrorCode.InvalidParams, 'An image path, URL, or base64 data is required');
-        }
-        const question = args.question || "What's in this image?";
-        console.error(`Processing image: ${args.image_path.substring(0, 100)}${args.image_path.length > 100 ? '...' : ''}`);
-        // Convert the image to base64
-        const { base64, mimeType } = await prepareImage(args.image_path);
-        // Create the content array for the OpenAI API
-        const content = [
-            {
-                type: 'text',
-                text: question
-            },
-            {
-                type: 'image_url',
-                image_url: {
-                    url: `data:${mimeType};base64,${base64}`
-                }
-            }
-        ];
-        // Select model with priority:
-        // 1. User-specified model
-        // 2. Default model from environment
-        // 3. Default free vision model (qwen/qwen2.5-vl-32b-instruct:free)
-        let model = args.model || defaultModel || DEFAULT_FREE_MODEL;
-        // If a model is specified but not our default free model, verify it exists
-        if (model !== DEFAULT_FREE_MODEL) {
-            try {
-                await openai.models.retrieve(model);
-            }
-            catch (error) {
-                console.error(`Specified model ${model} not found, falling back to auto-selection`);
-                model = await findSuitableFreeModel(openai);
-            }
-        }
-        console.error(`Making API call with model: ${model}`);
-        // Make the API call
+        const imageUrl = await prepareImageUrl(image_path);
         const completion = await openai.chat.completions.create({
-            model,
-            messages: [{
-                    role: 'user',
-                    content
-                }]
-        });
-        // Return the analysis result
-        return {
-            content: [
+            model: model || defaultModel || DEFAULT_MODEL,
+            messages: [
                 {
-                    type: 'text',
-                    text: completion.choices[0].message.content || '',
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: question || "What's in this image?" },
+                        { type: 'image_url', image_url: { url: imageUrl } },
+                    ],
                 },
             ],
-            metadata: {
-                model: completion.model,
-                usage: completion.usage
-            }
-        };
+        });
+        return { content: [{ type: 'text', text: completion.choices[0].message.content || '' }] };
     }
     catch (error) {
-        console.error('Error in image analysis:', error);
-        if (error instanceof McpError) {
-            throw error;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error analyzing image: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-            metadata: {
-                error_type: error instanceof Error ? error.constructor.name : 'Unknown',
-                error_message: error instanceof Error ? error.message : String(error)
-            }
-        };
+        const msg = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
     }
 }
-//# sourceMappingURL=analyze-image.js.map

package/dist/tool-handlers/chat-completion.d.ts

@@ -4,6 +4,7 @@ export interface ChatCompletionToolRequest {
     model?: string;
     messages: ChatCompletionMessageParam[];
     temperature?: number;
+    max_tokens?: number;
 }
 export declare function handleChatCompletion(request: {
     params: {

package/dist/tool-handlers/chat-completion.js

@@ -1,152 +1,19 @@
-// Maximum context tokens
-const MAX_CONTEXT_TOKENS = 200000;
-// Utility function to estimate token count (simplified)
-function estimateTokenCount(text) {
-    // Rough approximation: 4 characters per token
-    return Math.ceil(text.length / 4);
-}
-// Truncate messages to fit within the context window
-function truncateMessagesToFit(messages, maxTokens) {
-    const truncated = [];
-    let currentTokenCount = 0;
-    // Always include system message first if present
-    if (messages[0]?.role === 'system') {
-        truncated.push(messages[0]);
-        currentTokenCount += estimateTokenCount(messages[0].content);
-    }
-    // Add messages from the end, respecting the token limit
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        // Skip if it's the system message we've already added
-        if (i === 0 && message.role === 'system')
-            continue;
-        // For string content, estimate tokens directly
-        if (typeof message.content === 'string') {
-            const messageTokens = estimateTokenCount(message.content);
-            if (currentTokenCount + messageTokens > maxTokens)
-                break;
-            truncated.unshift(message);
-            currentTokenCount += messageTokens;
-        }
-        // For multimodal content (array), estimate tokens for text content
-        else if (Array.isArray(message.content)) {
-            let messageTokens = 0;
-            for (const part of message.content) {
-                if (part.type === 'text' && part.text) {
-                    messageTokens += estimateTokenCount(part.text);
-                }
-                else if (part.type === 'image_url') {
-                    // Add a token cost estimate for images - this is a simplification
-                    // Actual image token costs depend on resolution and model
-                    messageTokens += 1000;
-                }
-            }
-            if (currentTokenCount + messageTokens > maxTokens)
-                break;
-            truncated.unshift(message);
-            currentTokenCount += messageTokens;
-        }
-    }
-    return truncated;
-}
-// Find a suitable free model with the largest context window
-async function findSuitableFreeModel(openai) {
-    try {
-        // Query available models with 'free' in their name
-        const modelsResponse = await openai.models.list();
-        if (!modelsResponse || !modelsResponse.data || modelsResponse.data.length === 0) {
-            return 'deepseek/deepseek-chat-v3-0324:free'; // Fallback to a known model
-        }
-        // Filter models with 'free' in ID
-        const freeModels = modelsResponse.data
-            .filter(model => model.id.includes('free'))
-            .map(model => {
-            // Try to extract context length from the model object
-            let contextLength = 0;
-            try {
-                const modelAny = model; // Cast to any to access non-standard properties
-                if (typeof modelAny.context_length === 'number') {
-                    contextLength = modelAny.context_length;
-                }
-                else if (modelAny.context_window) {
-                    contextLength = parseInt(modelAny.context_window, 10);
-                }
-            }
-            catch (e) {
-                console.error(`Error parsing context length for model ${model.id}:`, e);
-            }
-            return {
-                id: model.id,
-                contextLength: contextLength || 0
-            };
-        });
-        if (freeModels.length === 0) {
-            return 'deepseek/deepseek-chat-v3-0324:free'; // Fallback if no free models found
-        }
-        // Sort by context length and pick the one with the largest context window
-        freeModels.sort((a, b) => b.contextLength - a.contextLength);
-        console.error(`Selected free model: ${freeModels[0].id} with context length: ${freeModels[0].contextLength}`);
-        return freeModels[0].id;
-    }
-    catch (error) {
-        console.error('Error finding suitable free model:', error);
-        return 'deepseek/deepseek-chat-v3-0324:free'; // Fallback to a known model
-    }
-}
 export async function handleChatCompletion(request, openai, defaultModel) {
-    const args = request.params.arguments;
-    // Validate message array
-    if (args.messages.length === 0) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: 'Messages array cannot be empty. At least one message is required.',
-                },
-            ],
-            isError: true,
-        };
+    const { messages, model, temperature, max_tokens } = request.params.arguments;
+    if (!messages?.length) {
+        return { content: [{ type: 'text', text: 'Messages array cannot be empty.' }], isError: true };
     }
     try {
-        // Select model with priority:
-        // 1. User-specified model
-        // 2. Default model from environment
-        // 3. Free model with the largest context window (selected automatically)
-        let model = args.model || defaultModel;
-        if (!model) {
-            model = await findSuitableFreeModel(openai);
-            console.error(`Using auto-selected model: ${model}`);
-        }
-        // Truncate messages to fit within context window
-        const truncatedMessages = truncateMessagesToFit(args.messages, MAX_CONTEXT_TOKENS);
-        console.error(`Making API call with model: ${model}`);
         const completion = await openai.chat.completions.create({
-            model,
-            messages: truncatedMessages,
-            temperature: args.temperature ?? 1,
+            model: model || defaultModel || 'nvidia/nemotron-nano-12b-v2-vl:free',
+            messages,
+            temperature: temperature ?? 1,
+            ...(max_tokens && { max_tokens }),
         });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: completion.choices[0].message.content || '',
-                },
-            ],
-        };
+        return { content: [{ type: 'text', text: completion.choices[0].message.content || '' }] };
     }
     catch (error) {
-        if (error instanceof Error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `OpenRouter API error: ${error.message}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        throw error;
+        const msg = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: 'text', text: `API error: ${msg}` }], isError: true };
     }
 }
-//# sourceMappingURL=chat-completion.js.map

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

@@ -0,0 +1,30 @@
+import OpenAI from 'openai';
+export interface GenerateImageToolRequest {
+    prompt: string;
+    model?: string;
+    save_path?: string;
+}
+export declare function handleGenerateImage(request: {
+    params: {
+        arguments: GenerateImageToolRequest;
+    };
+}, openai: OpenAI): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: ({
+        type: string;
+        text: string;
+        mimeType?: undefined;
+        data?: undefined;
+    } | {
+        type: string;
+        mimeType: string;
+        data: string;
+        text?: undefined;
+    })[];
+    isError?: undefined;
+}>;

package/dist/tool-handlers/generate-image.js

@@ -0,0 +1,82 @@
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+const DEFAULT_MODEL = 'google/gemini-2.5-flash-image';
+export async function handleGenerateImage(request, openai) {
+    const { prompt, model, save_path } = request.params.arguments;
+    if (!prompt?.trim()) {
+        return { content: [{ type: 'text', text: 'Prompt is required.' }], isError: true };
+    }
+    try {
+        const completion = await openai.chat.completions.create({
+            model: model || DEFAULT_MODEL,
+            messages: [{ role: 'user', content: `Generate an image: ${prompt}` }],
+        });
+        const message = completion.choices[0]?.message;
+        if (!message) {
+            return { content: [{ type: 'text', text: 'No response from model.' }], isError: true };
+        }
+        const base64 = extractBase64(message);
+        if (base64) {
+            if (save_path) {
+                const dir = dirname(save_path);
+                await fs.mkdir(dir, { recursive: true });
+                await fs.writeFile(save_path, Buffer.from(base64.data, 'base64'));
+                return {
+                    content: [
+                        { type: 'text', text: `Image saved to: ${save_path}` },
+                        { type: 'image', mimeType: base64.mime, data: base64.data },
+                    ],
+                };
+            }
+            return { content: [{ type: 'image', mimeType: base64.mime, data: base64.data }] };
+        }
+        const content = message.content;
+        const text = typeof content === 'string' ? content : JSON.stringify(content);
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+    }
+}
+function extractBase64(message) {
+    const images = message.images;
+    if (Array.isArray(images) && images.length) {
+        for (const img of images) {
+            const imageUrl = img.image_url;
+            const result = parseDataUrl(imageUrl?.url || img.url);
+            if (result)
+                return result;
+        }
+    }
+    if (Array.isArray(message.content)) {
+        for (const part of message.content) {
+            const iu = part.image_url;
+            const url = iu?.url || part.url;
+            if (url) {
+                const r = parseDataUrl(url);
+                if (r)
+                    return r;
+            }
+            const inline = part.inline_data;
+            if (inline?.data) {
+                return { data: inline.data, mime: inline.mime_type || 'image/png' };
+            }
+            if (part.type === 'image' && typeof part.data === 'string') {
+                return { data: part.data, mime: part.mime_type || 'image/png' };
+            }
+        }
+    }
+    if (typeof message.content === 'string') {
+        const match = message.content.match(/data:image\/([^;]+);base64,([A-Za-z0-9+/=]+)/);
+        if (match)
+            return { data: match[2], mime: `image/${match[1]}` };
+    }
+    return null;
+}
+function parseDataUrl(url) {
+    if (!url?.startsWith('data:'))
+        return null;
+    const match = url.match(/^data:([^;]+);base64,(.+)$/);
+    return match ? { data: match[2], mime: match[1] } : null;
+}