@amplify-studio/open-mcp 0.8.2 → 0.10.0

package/dist/types.js

@@ -1,40 +1,34 @@
 export function isSearXNGWebSearchArgs(args) {
-    return (typeof args === "object" &&
-        args !== null &&
-        "query" in args &&
-        typeof args.query === "string");
+    if (typeof args !== "object" ||
+        args === null ||
+        !("query" in args) ||
+        typeof args.query !== "string") {
+        return false;
+    }
+    const searchArgs = args;
+    if (searchArgs.limit !== undefined && (typeof searchArgs.limit !== "number" || searchArgs.limit < 1 || searchArgs.limit > 100)) {
+        return false;
+    }
+    return true;
 }
 export const WEB_SEARCH_TOOL = {
     name: "searxng_web_search",
-    description: "Performs a web search using the SearXNG API, ideal for general queries, news, articles, and online content. " +
-        "Use this for broad information gathering, recent events, or when you need diverse web sources.",
+    description: "Performs web search using the Gateway API Firecrawl search. " +
+        "Returns search results with title, content, and URL. " +
+        "Use this for general queries, news, articles, and online content.",
     inputSchema: {
         type: "object",
         properties: {
             query: {
                 type: "string",
-                description: "The search query. This is the main input for the web search",
+                description: "The search query string",
             },
-            pageno: {
+            limit: {
                 type: "number",
-                description: "Search page number (starts at 1)",
-                default: 1,
-            },
-            time_range: {
-                type: "string",
-                description: "Time range of search (day, month, year)",
-                enum: ["day", "month", "year"],
-            },
-            language: {
-                type: "string",
-                description: "Language code for search results (e.g., 'en', 'fr', 'de'). Default is instance-dependent.",
-                default: "all",
-            },
-            safesearch: {
-                type: "string",
-                description: "Safe search filter level (0: None, 1: Moderate, 2: Strict)",
-                enum: ["0", "1", "2"],
-                default: "0",
+                description: "Maximum number of results to return (default: 10, max: 100)",
+                default: 10,
+                minimum: 1,
+                maximum: 100,
             },
         },
         required: ["query"],
@@ -77,3 +71,103 @@ export const READ_URL_TOOL = {
         required: ["url"],
     },
 };
+export const IMAGE_UNDERSTAND_TOOL = {
+    name: "image_understand",
+    description: "Understand and analyze images, videos, and documents using Zhipu GLM-4.6V-Flash model. " +
+        "Supports visual Q&A, content description, OCR, document parsing, video understanding, " +
+        "and frontend code replication from screenshots. " +
+        "Accepts file paths, URLs, or base64 data. " +
+        "Use this when you need to extract information from visual content or answer questions about images/videos.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            file: {
+                type: "string",
+                description: "File path, URL, or base64 data (image, video, or PDF)",
+            },
+            prompt: {
+                type: "string",
+                description: "Question or instruction for the visual content analysis",
+            },
+            thinking: {
+                type: "boolean",
+                description: "Enable deep thinking mode for complex reasoning (default: true)",
+                default: true,
+            },
+        },
+        required: ["file", "prompt"],
+    },
+};
+export const IMAGE_GENERATE_TOOL = {
+    name: "image_generate",
+    description: "Generate images from text descriptions using Zhipu Cogview-3-Flash model. " +
+        "Supports multiple resolutions. " +
+        "Use this when you need to create visual content from text prompts.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "Text description of the image to generate",
+            },
+            size: {
+                type: "string",
+                enum: ["1024x1024", "768x1344", "864x1152", "1344x768", "1152x864", "1440x720", "720x1440"],
+                description: "Image size (default: 1024x1024)",
+                default: "1024x1024",
+            },
+        },
+        required: ["prompt"],
+    },
+};
+/**
+ * Generic type guard for checking if an object has a property of a specific type
+ */
+function hasProperty(args, prop, type) {
+    return (typeof args === "object" &&
+        args !== null &&
+        prop in args &&
+        typeof args[prop] === type);
+}
+export function isImageUnderstandArgs(args) {
+    if (!hasProperty(args, 'prompt', 'string') || !hasProperty(args, 'file', 'string')) {
+        return false;
+    }
+    const typedArgs = args;
+    if (typedArgs.thinking !== undefined && typeof typedArgs.thinking !== 'boolean') {
+        return false;
+    }
+    return true;
+}
+export function isImageGenerateArgs(args) {
+    if (!hasProperty(args, 'prompt', 'string')) {
+        return false;
+    }
+    const typedArgs = args;
+    if (typedArgs.size !== undefined && typeof typedArgs.size !== 'string') {
+        return false;
+    }
+    return true;
+}
+export function isWebUrlReadArgs(args) {
+    if (!hasProperty(args, 'url', 'string')) {
+        return false;
+    }
+    const urlArgs = args;
+    if (urlArgs.startChar !== undefined && (typeof urlArgs.startChar !== 'number' || urlArgs.startChar < 0)) {
+        return false;
+    }
+    if (urlArgs.maxLength !== undefined && (typeof urlArgs.maxLength !== 'number' || urlArgs.maxLength < 1)) {
+        return false;
+    }
+    if (urlArgs.section !== undefined && typeof urlArgs.section !== 'string') {
+        return false;
+    }
+    if (urlArgs.paragraphRange !== undefined && typeof urlArgs.paragraphRange !== 'string') {
+        return false;
+    }
+    if (urlArgs.readHeadings !== undefined && typeof urlArgs.readHeadings !== 'boolean') {
+        return false;
+    }
+    return true;
+}

package/dist/url-reader.d.ts

@@ -6,5 +6,6 @@ interface PaginationOptions {
     paragraphRange?: string;
     readHeadings?: boolean;
 }
-export declare function fetchAndConvertToMarkdown(server: Server, url: string, timeoutMs?: number, paginationOptions?: PaginationOptions): Promise<string>;
+export declare function fetchAndConvertToMarkdown(server: Server, url: string, timeoutMs?: number, // Increased default from 10s to 30s
+paginationOptions?: PaginationOptions): Promise<string>;
 export {};

package/dist/url-reader.js

@@ -1,7 +1,6 @@
-import { createProxyAgent } from "./proxy.js";
 import { logMessage } from "./logging.js";
 import { urlCache } from "./cache.js";
-import { createURLFormatError, createNetworkError, createServerError, createContentError, createTimeoutError, createEmptyContentWarning, createUnexpectedError } from "./error-handler.js";
+import { createURLFormatError, createConfigurationError, createNetworkError, createServerError, createContentError, createTimeoutError, createEmptyContentWarning, createUnexpectedError, GATEWAY_URL_REQUIRED_MESSAGE } from "./error-handler.js";
 function applyCharacterPagination(content, startChar = 0, maxLength) {
     if (startChar >= content.length) {
         return "";
@@ -99,7 +98,8 @@ function applyPaginationOptions(markdownContent, options) {
     }
     return result;
 }
-export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000, paginationOptions = {}) {
+export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 30000, // Increased default from 10s to 30s
+paginationOptions = {}) {
     const startTime = Date.now();
     logMessage(server, "info", `Fetching URL: ${url}`);
     // Check cache first
@@ -112,44 +112,40 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         return result;
     }
     // Validate URL format
-    let parsedUrl;
     try {
-        parsedUrl = new URL(url);
+        new URL(url);
     }
-    catch (error) {
+    catch {
         logMessage(server, "error", `Invalid URL format: ${url}`);
         throw createURLFormatError(url);
     }
     // Build gateway API URL
-    const gatewayUrl = process.env.GATEWAY_URL || "http://115.190.91.253:80";
+    const gatewayUrl = process.env.GATEWAY_URL;
+    if (!gatewayUrl) {
+        throw createConfigurationError(GATEWAY_URL_REQUIRED_MESSAGE);
+    }
     const gatewayApiUrl = `${gatewayUrl}/api/read/${encodeURIComponent(url)}`;
     // Create an AbortController instance
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        // Prepare request options with proxy support
+        // Prepare request options
         const requestOptions = {
             signal: controller.signal,
         };
-        // Add proxy dispatcher if proxy is configured
-        // Node.js fetch uses 'dispatcher' option for proxy, not 'agent'
-        const proxyAgent = createProxyAgent(gatewayApiUrl);
-        if (proxyAgent) {
-            requestOptions.dispatcher = proxyAgent;
-        }
         let response;
         try {
-            // Fetch the URL via gateway API with the abort signal
+            logMessage(server, "info", `Fetching from Gateway: ${gatewayApiUrl}`);
             response = await fetch(gatewayApiUrl, requestOptions);
+            logMessage(server, "info", `Gateway response status: ${response.status}`);
         }
         catch (error) {
-            const context = {
-                url,
-                gatewayUrl,
-                proxyAgent: !!proxyAgent,
-                timeout: timeoutMs
-            };
-            throw createNetworkError(error, context);
+            if (error.name === 'AbortError') {
+                logMessage(server, "error", `Gateway request timeout: ${url} (${timeoutMs}ms)`);
+                throw createTimeoutError(timeoutMs, url);
+            }
+            logMessage(server, "error", `Gateway network error: ${error.message}`, { url, gatewayUrl });
+            throw createNetworkError(error, { url, gatewayUrl, timeout: timeoutMs });
         }
         if (!response.ok) {
             let responseBody;
@@ -159,8 +155,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
             catch {
                 responseBody = '[Could not read response body]';
             }
-            const context = { url, gatewayUrl };
-            throw createServerError(response.status, response.statusText, responseBody, context);
+            throw createServerError(response.status, response.statusText, responseBody, { url, gatewayUrl });
         }
         // Retrieve content from gateway API (JSON response)
         let markdownContent;
@@ -180,7 +175,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         }
         if (!markdownContent || markdownContent.trim().length === 0) {
             logMessage(server, "warning", `Empty content from gateway: ${url}`);
-            return createEmptyContentWarning(url, 0, "");
+            return createEmptyContentWarning(url);
         }
         // Cache the markdown content from gateway
         urlCache.set(url, "", markdownContent);
@@ -209,8 +204,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         }
         // Catch any unexpected errors
         logMessage(server, "error", `Unexpected error fetching URL: ${url}`, error);
-        const context = { url };
-        throw createUnexpectedError(error, context);
+        throw createUnexpectedError(error, { url });
     }
     finally {
         // Clean up the timeout to prevent memory leaks

package/dist/utils/file-helper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect content type based on file extension
+ */
+export declare function detectFileType(filePath: string): 'image' | 'video' | 'file' | null;
+/**
+ * Normalize user input - detect if it's a local path, URL, or base64
+ */
+export declare function normalizeInput(input: string): {
+    type: 'local' | 'url' | 'base64';
+    value: string;
+};
+/**
+ * Read local file and convert to base64
+ */
+export declare function readAsBase64(filePath: string): Promise<string>;
+/**
+ * Get MIME type based on file extension
+ */
+export declare function getMimeType(filePath: string): string;

package/dist/utils/file-helper.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+// MIME type mapping for common extensions
+const MIME_TYPES = {
+    // Images
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    // Videos
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.mkv': 'video/x-matroska',
+    '.webm': 'video/webm',
+    // Documents
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+// Content type mappings by extension
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp']);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.mkv', '.webm']);
+const FILE_EXTENSIONS = new Set(['.pdf', '.txt', '.doc', '.docx', '.xls', '.xlsx']);
+/**
+ * Detect content type based on file extension
+ */
+export function detectFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (IMAGE_EXTENSIONS.has(ext))
+        return 'image';
+    if (VIDEO_EXTENSIONS.has(ext))
+        return 'video';
+    if (FILE_EXTENSIONS.has(ext))
+        return 'file';
+    return null;
+}
+/**
+ * Normalize user input - detect if it's a local path, URL, or base64
+ */
+export function normalizeInput(input) {
+    if (input.startsWith('data:')) {
+        return { type: 'base64', value: input };
+    }
+    if (input.startsWith('http://') || input.startsWith('https://')) {
+        return { type: 'url', value: input };
+    }
+    if (/^[A-Za-z0-9+/=]{20,}$/.test(input) && !input.includes(' ')) {
+        return { type: 'base64', value: input };
+    }
+    return { type: 'local', value: input };
+}
+/**
+ * Read local file and convert to base64
+ */
+export async function readAsBase64(filePath) {
+    try {
+        const buffer = await fs.readFile(filePath);
+        return buffer.toString('base64');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read file: ${filePath}. Error: ${message}`);
+    }
+}
+/**
+ * Get MIME type based on file extension
+ */
+export function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_TYPES[ext] || 'application/octet-stream';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@amplify-studio/open-mcp",
-    "version": "0.8.2",
+    "version": "0.10.0",
     "description": "Open MCP server for web search and URL reading via Gateway API",
     "license": "MIT",
     "author": "Amplify Studio (https://github.com/amplify-studio)",
@@ -39,7 +39,7 @@
         "test": "SEARXNG_URL=https://test-searx.example.com tsx __tests__/run-all.ts",
         "test:coverage": "SEARXNG_URL=https://test-searx.example.com c8 --reporter=text tsx __tests__/run-all.ts",
         "bootstrap": "npm install && npm run build",
-        "inspector": "DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector node dist/index.js",
+        "inspector": "DANGEROUSLY_OMIT_AUTH=true GATEWAY_URL=http://localhost:80 npx @modelcontextprotocol/inspector node dist/index.js",
         "postversion": "TAG=$(node scripts/update-version.js | tail -1) && git add src/index.ts && git commit --amend --no-edit && git tag -f $TAG"
     },
     "dependencies": {
@@ -47,15 +47,16 @@
         "@types/cors": "^2.8.19",
         "@types/express": "^5.0.3",
         "cors": "^2.8.5",
+        "dotenv": "^17.2.3",
         "express": "^5.1.0",
         "node-html-markdown": "^1.3.0",
         "undici": "^6.20.1"
     },
     "devDependencies": {
-        "mcp-evals": "^1.0.18",
         "@types/node": "^22.17.2",
         "@types/supertest": "^6.0.3",
         "c8": "^10.1.3",
+        "mcp-evals": "^1.0.18",
         "shx": "^0.4.0",
         "supertest": "^7.1.4",
         "tsx": "^4.20.5",