@amplify-studio/open-mcp 0.8.2 → 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.d.ts

@@ -1,2 +1,2 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-export declare function performWebSearch(server: Server, query: string, pageno?: number, time_range?: string, language?: string, safesearch?: string): Promise<string>;
+export declare function performWebSearch(server: Server, query: string, limit?: number): Promise<string>;

package/dist/search.js

@@ -1,82 +1,64 @@
-import { createProxyAgent } from "./proxy.js";
 import { logMessage } from "./logging.js";
-import { createConfigurationError, createNetworkError, createServerError, createJSONError, createDataError, createNoResultsMessage } from "./error-handler.js";
-export async function performWebSearch(server, query, pageno = 1, time_range, language = "all", safesearch) {
+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();
-    // Build detailed log message with all parameters
-    const searchParams = [
-        `page ${pageno}`,
-        `lang: ${language}`,
-        time_range ? `time: ${time_range}` : null,
-        safesearch ? `safesearch: ${safesearch}` : null
-    ].filter(Boolean).join(", ");
-    logMessage(server, "info", `Starting web search: "${query}" (${searchParams})`);
-    const gatewayUrl = process.env.GATEWAY_URL || "http://115.190.91.253:80";
-    // Validate that gatewayUrl is a valid URL
-    let parsedUrl;
-    try {
-        parsedUrl = new URL(gatewayUrl);
-    }
-    catch (error) {
-        throw createConfigurationError(`Invalid GATEWAY_URL format: ${gatewayUrl}. Use format: http://115.190.91.253:80`);
-    }
-    const url = new URL('/api/search/', parsedUrl);
-    url.searchParams.set("q", query);
-    url.searchParams.set("format", "json");
-    url.searchParams.set("pageno", pageno.toString());
-    if (time_range !== undefined &&
-        ["day", "month", "year"].includes(time_range)) {
-        url.searchParams.set("time_range", time_range);
+    logMessage(server, "info", `Starting web search: "${query}" (limit: ${limit})`);
+    const gatewayUrl = process.env.GATEWAY_URL;
+    if (!gatewayUrl) {
+        throw createConfigurationError(GATEWAY_URL_REQUIRED_MESSAGE);
     }
-    if (language && language !== "all") {
-        url.searchParams.set("language", language);
+    // Build and validate the endpoint URL
+    let searchUrl;
+    try {
+        searchUrl = new URL('/api/firecrawl-search', gatewayUrl);
     }
-    if (safesearch !== undefined && ["0", "1", "2"].includes(safesearch)) {
-        url.searchParams.set("safesearch", safesearch);
+    catch {
+        throw createConfigurationError(`Invalid GATEWAY_URL format: ${gatewayUrl}. Use format: http://your-gateway.com:80`);
     }
-    // Prepare request options with headers
+    // Prepare request body
+    const requestBody = {
+        query,
+        limit
+    };
+    // Prepare request options
     const requestOptions = {
-        method: "GET"
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
     };
-    // Add proxy dispatcher if proxy is configured
-    // Node.js fetch uses 'dispatcher' option for proxy, not 'agent'
-    const proxyAgent = createProxyAgent(url.toString());
-    if (proxyAgent) {
-        requestOptions.dispatcher = proxyAgent;
-    }
-    // Add basic authentication if credentials are provided
+    // Add basic authentication if configured
     const username = process.env.AUTH_USERNAME;
     const password = process.env.AUTH_PASSWORD;
     if (username && password) {
         const base64Auth = Buffer.from(`${username}:${password}`).toString('base64');
-        requestOptions.headers = {
-            ...requestOptions.headers,
-            'Authorization': `Basic ${base64Auth}`
-        };
+        requestOptions.headers['Authorization'] = `Basic ${base64Auth}`;
     }
-    // Add User-Agent header if configured
+    // Add User-Agent if configured
     const userAgent = process.env.USER_AGENT;
     if (userAgent) {
-        requestOptions.headers = {
-            ...requestOptions.headers,
-            'User-Agent': userAgent
-        };
+        requestOptions.headers['User-Agent'] = userAgent;
     }
-    // Fetch with enhanced error handling
+    // 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 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;
@@ -86,16 +68,12 @@ export async function performWebSearch(server, query, pageno = 1, time_range, la
         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;
     try {
-        data = (await response.json());
+        data = await response.json();
     }
     catch (error) {
         let responseText;
@@ -105,31 +83,39 @@ export async function performWebSearch(server, query, pageno = 1, time_range, la
         catch {
             responseText = '[Could not read response text]';
         }
-        const context = { url: url.toString() };
-        throw createJSONError(responseText, context);
+        throw new Error(`Failed to parse JSON response: ${responseText}`);
     }
-    if (!data.results) {
-        const context = { url: url.toString(), query };
-        throw createDataError(data, context);
+    // Handle Firecrawl API response format: {success: true, data: [...]}
+    let results = data.results || data.data || [];
+    // If wrapped in success object
+    if (data.success && data.data) {
+        results = data.data;
+    }
+    if (!Array.isArray(results)) {
+        throw new Error(`Invalid response format: results is not an array`);
     }
-    const results = data.results.map((result) => ({
-        title: result.title || "",
-        content: result.content || "",
-        url: result.url || "",
-        score: result.score || 0,
-    }));
     if (results.length === 0) {
         logMessage(server, "info", `No results found for query: "${query}"`);
-        return createNoResultsMessage(query);
+        return JSON.stringify({
+            query,
+            results: [],
+            totalCount: 0,
+            duration: `${Date.now() - startTime}ms`
+        }, null, 2);
     }
+    // Format results (API returns: url, title, description)
+    const formattedResults = results.map((result) => ({
+        title: result.title || "",
+        content: result.description || result.content || "",
+        url: result.url || result.link || ""
+    }));
     const duration = Date.now() - startTime;
-    logMessage(server, "info", `Search completed: "${query}" (${searchParams}) - ${results.length} results in ${duration}ms`);
+    logMessage(server, "info", `Search completed: "${query}" - ${formattedResults.length} results in ${duration}ms`);
     // Return as JSON string
     return JSON.stringify({
         query,
-        results,
-        totalCount: results.length,
-        duration: `${duration}ms`,
-        page: pageno
+        results: formattedResults,
+        totalCount: formattedResults.length,
+        duration: `${duration}ms`
     }, null, 2);
 }

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,18 +1,29 @@
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
-export interface SearXNGWeb {
-    results: Array<{
-        title: string;
-        content: string;
-        url: string;
-        score: number;
-    }>;
-}
 export declare function isSearXNGWebSearchArgs(args: unknown): args is {
     query: string;
-    pageno?: number;
-    time_range?: string;
-    language?: string;
-    safesearch?: 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;
+}