@amplify-studio/open-mcp 0.9.0 → 0.10.0

package/dist/resources.js

@@ -8,15 +8,13 @@ export function createConfigResource() {
             description: "MCP server for SearXNG integration via Gateway API"
         },
         environment: {
-            gatewayUrl: process.env.GATEWAY_URL || "http://115.190.91.253:80 (default)",
+            gatewayUrl: process.env.GATEWAY_URL || "Not configured",
             hasAuth: !!(process.env.AUTH_USERNAME && process.env.AUTH_PASSWORD),
-            hasProxy: !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy),
-            hasNoProxy: !!(process.env.NO_PROXY || process.env.no_proxy),
             nodeVersion: process.version,
             currentLogLevel: getCurrentLogLevel()
         },
         capabilities: {
-            tools: ["searxng_web_search", "web_url_read"],
+            tools: ["searxng_web_search", "web_url_read", "image_understand", "image_generate"],
             logging: true,
             resources: true,
             transports: process.env.MCP_HTTP_PORT ? ["stdio", "http"] : ["stdio"]
@@ -33,30 +31,46 @@ This is a Model Context Protocol (MCP) server that provides web search capabilit
 ## Available Tools
 
 ### 1. searxng_web_search
-Performs web searches using the configured Gateway API.
+Performs web searches using the configured Gateway API (Firecrawl search).
 
 **Parameters:**
 - \`query\` (required): The search query string
-- \`pageno\` (optional): Page number (default: 1)
-- \`time_range\` (optional): Filter by time - "day", "month", or "year"
-- \`language\` (optional): Language code like "en", "fr", "de" (default: "all")
-- \`safesearch\` (optional): Safe search level - "0" (none), "1" (moderate), "2" (strict)
+- \`limit\` (optional): Maximum number of results (default: 10, max: 100)
 
 ### 2. web_url_read
 Reads and converts web page content to Markdown format via Gateway API.
 
 **Parameters:**
 - \`url\` (required): The URL to fetch and convert
+- \`startChar\` (optional): Starting character position (default: 0)
+- \`maxLength\` (optional): Maximum number of characters to return
+- \`section\` (optional): Extract content under a specific heading
+- \`paragraphRange\` (optional): Return specific paragraph ranges (e.g., "1-5", "3", "10-")
+- \`readHeadings\` (optional): Return only a list of headings
+
+### 3. image_understand
+Analyze images, videos, and documents using Zhipu GLM-4.6V-Flash model.
+
+**Parameters:**
+- \`file\` (required): File path, URL, or base64 data
+- \`prompt\` (required): Question or instruction for analysis
+- \`thinking\` (optional): Enable deep thinking mode (default: true)
+
+### 4. image_generate
+Generate images from text using Zhipu Cogview-3-Flash model.
+
+**Parameters:**
+- \`prompt\` (required): Text description of the image to generate
+- \`size\` (optional): Image size (default: "1024x1024")
 
 ## Configuration
 
-### Optional Environment Variables
-- \`GATEWAY_URL\`: URL of the Gateway API (default: http://115.190.91.253:80)
+### Required Environment Variables
+- \`GATEWAY_URL\`: URL of the Gateway API
 
 ### Optional Environment Variables
+- \`ZHIPUAI_API_KEY\`: API key for image tools (understand/generate)
 - \`AUTH_USERNAME\` & \`AUTH_PASSWORD\`: Basic authentication for Gateway
-- \`HTTP_PROXY\` / \`HTTPS_PROXY\`: Proxy server configuration
-- \`NO_PROXY\` / \`no_proxy\`: Comma-separated list of hosts to bypass proxy
 - \`MCP_HTTP_PORT\`: Enable HTTP transport on specified port
 
 ## Transport Modes
@@ -69,10 +83,10 @@ RESTful HTTP transport for web applications. Set \`MCP_HTTP_PORT\` to enable.
 
 ## Usage Examples
 
-### Search for recent news
+### Search the web
 \`\`\`
 Tool: searxng_web_search
-Args: {"query": "latest AI developments", "time_range": "day"}
+Args: {"query": "latest AI developments", "limit": 10}
 \`\`\`
 
 ### Read a specific article
@@ -81,15 +95,28 @@ Tool: web_url_read
 Args: {"url": "https://example.com/article"}
 \`\`\`
 
+### Analyze an image
+\`\`\`
+Tool: image_understand
+Args: {"file": "https://example.com/image.jpg", "prompt": "Describe this image"}
+\`\`\`
+
+### Generate an image
+\`\`\`
+Tool: image_generate
+Args: {"prompt": "A sunset over mountains", "size": "1024x1024"}
+\`\`\`
+
 ## Troubleshooting
 
 1. **Network errors**: Check if Gateway API is running and accessible
 2. **Empty results**: Try different search terms or check Gateway service
 3. **Timeout errors**: The server has a 10-second timeout for URL fetching
+4. **Image tools not working**: Ensure ZHIPUAI_API_KEY is set
 
 Use logging level "debug" for detailed request information.
 
 ## Current Configuration
-See the "Current Configuration" resource for live settings.
+See the "config://server-config" resource for live settings.
 `;
 }

package/dist/search.js

@@ -1,19 +1,20 @@
-import { createProxyAgent } from "./proxy.js";
 import { logMessage } from "./logging.js";
-import { createConfigurationError, createNetworkError, createServerError } from "./error-handler.js";
+import { createConfigurationError, createNetworkError, createServerError, createTimeoutError, GATEWAY_URL_REQUIRED_MESSAGE } from "./error-handler.js";
 export async function performWebSearch(server, query, limit = 10) {
     const startTime = Date.now();
     logMessage(server, "info", `Starting web search: "${query}" (limit: ${limit})`);
-    const gatewayUrl = process.env.GATEWAY_URL || "http://115.190.91.253:80";
-    // Validate gateway URL
-    let parsedUrl;
+    const gatewayUrl = process.env.GATEWAY_URL;
+    if (!gatewayUrl) {
+        throw createConfigurationError(GATEWAY_URL_REQUIRED_MESSAGE);
+    }
+    // Build and validate the endpoint URL
+    let searchUrl;
     try {
-        parsedUrl = new URL(gatewayUrl);
+        searchUrl = new URL('/api/firecrawl-search', gatewayUrl);
     }
-    catch (error) {
-        throw createConfigurationError(`Invalid GATEWAY_URL format: ${gatewayUrl}. Use format: http://115.190.91.253:80`);
+    catch {
+        throw createConfigurationError(`Invalid GATEWAY_URL format: ${gatewayUrl}. Use format: http://your-gateway.com:80`);
     }
-    const url = new URL('/api/firecrawl-search', parsedUrl);
     // Prepare request body
     const requestBody = {
         query,
@@ -27,11 +28,6 @@ export async function performWebSearch(server, query, limit = 10) {
         },
         body: JSON.stringify(requestBody)
     };
-    // Add proxy dispatcher if configured
-    const proxyAgent = createProxyAgent(url.toString());
-    if (proxyAgent) {
-        requestOptions.dispatcher = proxyAgent;
-    }
     // Add basic authentication if configured
     const username = process.env.AUTH_USERNAME;
     const password = process.env.AUTH_PASSWORD;
@@ -44,21 +40,25 @@ export async function performWebSearch(server, query, limit = 10) {
     if (userAgent) {
         requestOptions.headers['User-Agent'] = userAgent;
     }
+    // Add timeout to prevent hanging
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+    requestOptions.signal = controller.signal;
     // Fetch with error handling
     let response;
     try {
-        logMessage(server, "info", `Making POST request to: ${url.toString()}`);
-        response = await fetch(url.toString(), requestOptions);
+        logMessage(server, "info", `Making POST request to: ${searchUrl.toString()}`);
+        response = await fetch(searchUrl.toString(), requestOptions);
+        clearTimeout(timeoutId);
     }
     catch (error) {
-        logMessage(server, "error", `Network error during search request: ${error.message}`, { query, url: url.toString() });
-        const context = {
-            url: url.toString(),
-            gatewayUrl,
-            proxyAgent: !!proxyAgent,
-            username
-        };
-        throw createNetworkError(error, context);
+        clearTimeout(timeoutId);
+        if (error.name === 'AbortError') {
+            logMessage(server, "error", `Request timeout after 30s: ${searchUrl.toString()}`);
+            throw createTimeoutError(30000, searchUrl.toString());
+        }
+        logMessage(server, "error", `Network error during search request: ${error.message}`, { query, url: searchUrl.toString() });
+        throw createNetworkError(error, { url: searchUrl.toString(), gatewayUrl });
     }
     if (!response.ok) {
         let responseBody;
@@ -68,11 +68,7 @@ export async function performWebSearch(server, query, limit = 10) {
         catch {
             responseBody = '[Could not read response body]';
         }
-        const context = {
-            url: url.toString(),
-            gatewayUrl
-        };
-        throw createServerError(response.status, response.statusText, responseBody, context);
+        throw createServerError(response.status, response.statusText, responseBody, { url: searchUrl.toString(), gatewayUrl });
     }
     // Parse JSON response
     let data;
@@ -87,7 +83,6 @@ export async function performWebSearch(server, query, limit = 10) {
         catch {
             responseText = '[Could not read response text]';
         }
-        const context = { url: url.toString() };
         throw new Error(`Failed to parse JSON response: ${responseText}`);
     }
     // Handle Firecrawl API response format: {success: true, data: [...]}

package/dist/tools/image-generate.d.ts

@@ -0,0 +1,5 @@
+import type { ImageGenerateArgs } from '../types.js';
+/**
+ * Main function: Generate image from text prompt
+ */
+export declare function generateImage(args: ImageGenerateArgs): Promise<string>;

package/dist/tools/image-generate.js

@@ -0,0 +1,29 @@
+import { callImageGenAPI } from '../api/zhipu.js';
+const VALID_SIZES = new Set([
+    '1024x1024', '768x1344', '864x1152', '1344x768',
+    '1152x864', '1440x720', '720x1440'
+]);
+const MAX_PROMPT_LENGTH = 4000;
+/**
+ * Validate image generation parameters
+ */
+function validateImageGenArgs(args) {
+    const { prompt, size } = args;
+    if (!prompt?.trim()) {
+        throw new Error('Prompt is required');
+    }
+    if (prompt.length > MAX_PROMPT_LENGTH) {
+        throw new Error(`Prompt is too long (max ${MAX_PROMPT_LENGTH} characters)`);
+    }
+    if (size && !VALID_SIZES.has(size)) {
+        throw new Error(`Invalid size: ${size}. Must be one of: ${Array.from(VALID_SIZES).join(', ')}`);
+    }
+}
+/**
+ * Main function: Generate image from text prompt
+ */
+export async function generateImage(args) {
+    validateImageGenArgs(args);
+    const { prompt, size = '1024x1024' } = args;
+    return callImageGenAPI(prompt, size);
+}

package/dist/tools/image-ocr.d.ts

@@ -0,0 +1,5 @@
+import type { ImageOCRArgs } from '../types.js';
+/**
+ * Main function: Extract text from image using OCR
+ */
+export declare function extractTextFromImage(args: ImageOCRArgs): Promise<string>;

package/dist/tools/image-ocr.js

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises';
+const SUPPORTED_FORMATS = new Set(['png', 'jpg', 'jpeg', 'bmp', 'gif']);
+const MAX_IMAGE_SIZE = 10485760; // 10MB
+const LOW_CONFIDENCE_THRESHOLD = 0.5;
+const DEFAULT_CONFIDENCE = 0.9;
+/**
+ * Check if path is a local file
+ */
+function isLocalFile(imagePath) {
+    return imagePath.startsWith('/') ||
+        imagePath.startsWith('./') ||
+        imagePath.startsWith('../');
+}
+/**
+ * Get file extension from path
+ */
+function getFileExtension(imagePath) {
+    return imagePath.split('.').pop()?.toLowerCase() ?? '';
+}
+/**
+ * Validate image file format and size
+ */
+async function validateImage(imagePath) {
+    const ext = getFileExtension(imagePath);
+    if (!SUPPORTED_FORMATS.has(ext)) {
+        throw new Error(`Unsupported image format: ${ext}. Supported formats: ${Array.from(SUPPORTED_FORMATS).join(', ')}`);
+    }
+    if (!isLocalFile(imagePath)) {
+        return;
+    }
+    try {
+        const buffer = await readFile(imagePath);
+        const maxSize = Number(process.env.MAX_IMAGE_SIZE) || MAX_IMAGE_SIZE;
+        if (buffer.length > maxSize) {
+            throw new Error(`Image too large: ${buffer.length} bytes (max: ${maxSize} bytes)`);
+        }
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === 'ENOENT') {
+            throw new Error(`Image file not found: ${imagePath}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Call PaddleOCR service
+ */
+async function callPaddleOCR(imagePath) {
+    const paddleocrUrl = process.env.PADDLEOCR_URL || 'http://localhost:8080';
+    const imageBuffer = await readFile(imagePath);
+    const base64Image = imageBuffer.toString('base64');
+    const response = await fetch(`${paddleocrUrl}/ocr`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            image: base64Image,
+            lang: 'auto'
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        throw new Error(`OCR service error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+/**
+ * Main function: Extract text from image using OCR
+ */
+export async function extractTextFromImage(args) {
+    const { imageFile } = args;
+    if (!imageFile?.trim()) {
+        throw new Error('Image file path is required');
+    }
+    const startTime = Date.now();
+    try {
+        await validateImage(imageFile);
+        const result = await callPaddleOCR(imageFile);
+        const processingTime = `${((Date.now() - startTime) / 1000).toFixed(2)}s`;
+        const confidence = result.confidence || DEFAULT_CONFIDENCE;
+        const warning = confidence < LOW_CONFIDENCE_THRESHOLD
+            ? 'Low confidence score, image quality may be poor'
+            : undefined;
+        const response = {
+            success: true,
+            text: result.text,
+            confidence,
+            language: result.language || 'unknown',
+            processingTime,
+            engine: 'paddleocr',
+            warning
+        };
+        return JSON.stringify(response, null, 2);
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === 'ECONNREFUSED') {
+            throw new Error('OCR service is not running. Please start the PaddleOCR service.');
+        }
+        throw error;
+    }
+}

package/dist/tools/image-understand.d.ts

@@ -0,0 +1,5 @@
+import type { ImageUnderstandArgs } from '../types.js';
+/**
+ * Main function: Process image understanding request
+ */
+export declare function understandImage(args: ImageUnderstandArgs): Promise<string>;

package/dist/tools/image-understand.js

@@ -0,0 +1,54 @@
+import { detectFileType, getMimeType, normalizeInput, readAsBase64, } from '../utils/file-helper.js';
+import { callVisionAPI } from '../api/zhipu.js';
+const DEFAULT_MIME_TYPES = {
+    image: 'image/png',
+    video: 'video/mp4',
+};
+/**
+ * Convert file input to data URL
+ */
+async function fileToDataUrl(file) {
+    const normalized = normalizeInput(file);
+    if (normalized.type === 'local') {
+        const base64 = await readAsBase64(normalized.value);
+        const mimeType = getMimeType(normalized.value);
+        return `data:${mimeType};base64,${base64}`;
+    }
+    if (normalized.type === 'base64' && !normalized.value.startsWith('data:')) {
+        const fileType = detectFileType(normalized.value);
+        const mimeType = DEFAULT_MIME_TYPES[fileType] ?? 'application/octet-stream';
+        return `data:${mimeType};base64,${normalized.value}`;
+    }
+    return normalized.value;
+}
+/**
+ * Create content item based on file type
+ */
+function createContentItem(dataUrl, file) {
+    const fileType = detectFileType(file.split('?')[0]);
+    if (fileType === 'image') {
+        return { type: 'image_url', image_url: { url: dataUrl } };
+    }
+    if (fileType === 'video') {
+        return { type: 'video_url', video_url: { url: dataUrl } };
+    }
+    return { type: 'file_url', file_url: { url: dataUrl } };
+}
+/**
+ * Main function: Process image understanding request
+ */
+export async function understandImage(args) {
+    const { file, prompt, thinking = true } = args;
+    if (!file?.trim()) {
+        throw new Error('File is required');
+    }
+    if (!prompt?.trim()) {
+        throw new Error('Prompt is required');
+    }
+    const dataUrl = await fileToDataUrl(file);
+    const contentItem = createContentItem(dataUrl, file);
+    return callVisionAPI([{
+            role: 'user',
+            content: [contentItem, { type: 'text', text: prompt }]
+        }], thinking);
+}

package/dist/types.d.ts

@@ -1,14 +1,29 @@
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
-export interface SearXNGWeb {
-    results: Array<{
-        title: string;
-        content: string;
-        url: string;
-    }>;
-}
 export declare function isSearXNGWebSearchArgs(args: unknown): args is {
     query: string;
     limit?: number;
 };
 export declare const WEB_SEARCH_TOOL: Tool;
 export declare const READ_URL_TOOL: Tool;
+export declare const IMAGE_UNDERSTAND_TOOL: Tool;
+export declare const IMAGE_GENERATE_TOOL: Tool;
+export interface ImageUnderstandArgs {
+    file: string;
+    prompt: string;
+    thinking?: boolean;
+}
+export interface ImageGenerateArgs {
+    prompt: string;
+    size?: string;
+}
+export declare function isImageUnderstandArgs(args: unknown): args is ImageUnderstandArgs;
+export declare function isImageGenerateArgs(args: unknown): args is ImageGenerateArgs;
+export declare function isWebUrlReadArgs(args: unknown): args is WebUrlReadArgs;
+export interface WebUrlReadArgs {
+    url: string;
+    startChar?: number;
+    maxLength?: number;
+    section?: string;
+    paragraphRange?: string;
+    readHeadings?: boolean;
+}

package/dist/types.js

@@ -1,13 +1,20 @@
 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 web search using the Gateway API Firecrawl search. " +
-        "Returns search results with title, content, URL, and relevance score. " +
+        "Returns search results with title, content, and URL. " +
         "Use this for general queries, news, articles, and online content.",
     inputSchema: {
         type: "object",
@@ -64,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 {};