@amplify-studio/open-mcp 0.9.0 → 0.10.0

package/dist/api/zhipu.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Zhipu AI API Client
+ * Handles HTTP requests to Zhipu AI vision and image generation APIs
+ */
+export interface VisionContentItem {
+    type: 'image_url' | 'video_url' | 'file_url';
+    image_url?: {
+        url: string;
+    };
+    video_url?: {
+        url: string;
+    };
+    file_url?: {
+        url: string;
+    };
+}
+interface VisionMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: Array<VisionContentItem | {
+        type: 'text';
+        text: string;
+    }>;
+}
+/**
+ * Call GLM-4.6V-Flash for image/video/document understanding
+ */
+export declare function callVisionAPI(messages: VisionMessage[], thinking?: boolean): Promise<string>;
+/**
+ * Call Cogview-3-Flash for image generation
+ */
+export declare function callImageGenAPI(prompt: string, size?: string): Promise<string>;
+export {};

package/dist/api/zhipu.js

@@ -0,0 +1,68 @@
+/**
+ * Zhipu AI API Client
+ * Handles HTTP requests to Zhipu AI vision and image generation APIs
+ */
+const ZHIPU_API_BASE = 'https://open.bigmodel.cn/api/paas/v4';
+function getZhipuApiKey() {
+    const apiKey = process.env.ZHIPUAI_API_KEY;
+    if (!apiKey) {
+        throw new Error('ZHIPUAI_API_KEY environment variable is required');
+    }
+    return apiKey;
+}
+async function handleAPIError(response) {
+    const errorData = await response.json().catch(() => ({}));
+    const errorMessage = errorData.error?.message || `HTTP ${response.status}`;
+    const errorPrefix = response.status === 401
+        ? 'Authentication failed'
+        : response.status >= 500
+            ? 'Server error'
+            : 'API error';
+    throw new Error(`${errorPrefix}: ${errorMessage}`);
+}
+async function fetchZhipuAPI(endpoint, body) {
+    const response = await fetch(`${ZHIPU_API_BASE}${endpoint}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${getZhipuApiKey()}`
+        },
+        body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+        await handleAPIError(response);
+    }
+    return response;
+}
+/**
+ * Call GLM-4.6V-Flash for image/video/document understanding
+ */
+export async function callVisionAPI(messages, thinking = false) {
+    const response = await fetchZhipuAPI('/chat/completions', {
+        model: 'glm-4.6v-flash',
+        messages,
+        thinking: {
+            type: thinking ? 'enabled' : 'disabled'
+        }
+    });
+    const data = await response.json();
+    if (!data.choices?.[0]?.message?.content) {
+        throw new Error('No response from vision API');
+    }
+    return data.choices[0].message.content;
+}
+/**
+ * Call Cogview-3-Flash for image generation
+ */
+export async function callImageGenAPI(prompt, size = '1024x1024') {
+    const response = await fetchZhipuAPI('/images/generations', {
+        model: 'cogview-3-flash',
+        prompt,
+        size
+    });
+    const data = await response.json();
+    if (!data.data?.[0]?.url) {
+        throw new Error('No images generated');
+    }
+    return data.data[0].url;
+}

package/dist/error-handler.d.ts

@@ -2,28 +2,22 @@
  * Concise error handling for MCP SearXNG server
  * Provides clear, focused error messages that identify the root cause
  */
+export declare const GATEWAY_URL_REQUIRED_MESSAGE = "GATEWAY_URL is required. Set it to your Gateway API URL (e.g., http://your-gateway.com:80)";
 export interface ErrorContext {
     url?: string;
-    searxngUrl?: string;
     gatewayUrl?: string;
-    proxyAgent?: boolean;
-    username?: string;
     timeout?: number;
-    query?: string;
 }
 export declare class MCPSearXNGError extends Error {
     constructor(message: string);
 }
 export declare function createConfigurationError(message: string): MCPSearXNGError;
 export declare function createNetworkError(error: any, context: ErrorContext): MCPSearXNGError;
-export declare function createServerError(status: number, statusText: string, responseBody: string, context: ErrorContext): MCPSearXNGError;
-export declare function createJSONError(responseText: string, context: ErrorContext): MCPSearXNGError;
-export declare function createDataError(data: any, context: ErrorContext): MCPSearXNGError;
+export declare function createServerError(status: number, statusText: string, _responseBody: string, context: ErrorContext): MCPSearXNGError;
 export declare function createNoResultsMessage(query: string): string;
 export declare function createURLFormatError(url: string): MCPSearXNGError;
 export declare function createContentError(message: string, url: string): MCPSearXNGError;
-export declare function createConversionError(error: any, url: string, htmlContent: string): MCPSearXNGError;
 export declare function createTimeoutError(timeout: number, url: string): MCPSearXNGError;
-export declare function createEmptyContentWarning(url: string, htmlLength: number, htmlPreview: string): string;
+export declare function createEmptyContentWarning(url: string): string;
 export declare function createUnexpectedError(error: any, context: ErrorContext): MCPSearXNGError;
 export declare function validateEnvironment(): string | null;

package/dist/error-handler.js

@@ -2,6 +2,7 @@
  * Concise error handling for MCP SearXNG server
  * Provides clear, focused error messages that identify the root cause
  */
+export const GATEWAY_URL_REQUIRED_MESSAGE = "GATEWAY_URL is required. Set it to your Gateway API URL (e.g., http://your-gateway.com:80)";
 export class MCPSearXNGError extends Error {
     constructor(message) {
         super(message);
@@ -12,7 +13,7 @@ export function createConfigurationError(message) {
     return new MCPSearXNGError(`🔧 Configuration Error: ${message}`);
 }
 export function createNetworkError(error, context) {
-    const target = context.searxngUrl ? 'SearXNG server' : (context.gatewayUrl ? 'Gateway server' : 'website');
+    const target = context.gatewayUrl ? 'Gateway server' : 'target server';
     if (error.code === 'ECONNREFUSED') {
         return new MCPSearXNGError(`🌐 Connection Error: ${target} is not responding (${context.url})`);
     }
@@ -26,27 +27,22 @@ export function createNetworkError(error, context) {
     if (error.message?.includes('certificate')) {
         return new MCPSearXNGError(`🌐 SSL Error: Certificate problem with ${target}`);
     }
-    // For generic fetch failures, provide root cause guidance
     const errorMsg = error.message || error.code || 'Connection failed';
     if (errorMsg === 'fetch failed' || errorMsg === 'Connection failed') {
-        const guidance = context.searxngUrl
-            ? 'Check if the SEARXNG_URL is correct and the SearXNG server is available'
-            : (context.gatewayUrl
-                ? 'Check if the GATEWAY_URL is correct and the Gateway server is available'
-                : 'Check if the website URL is accessible');
+        const guidance = context.gatewayUrl
+            ? 'Check if the GATEWAY_URL is correct and the Gateway server is available'
+            : 'Check if the target URL is accessible';
         return new MCPSearXNGError(`🌐 Network Error: ${errorMsg}. ${guidance}`);
     }
     return new MCPSearXNGError(`🌐 Network Error: ${errorMsg}`);
 }
-export function createServerError(status, statusText, responseBody, context) {
-    const target = context.searxngUrl ? 'SearXNG server' : (context.gatewayUrl ? 'Gateway server' : 'Website');
+export function createServerError(status, statusText, _responseBody, context) {
+    const target = context.gatewayUrl ? 'Gateway server' : 'Website';
     if (status === 403) {
-        const reason = context.searxngUrl ? 'Authentication required or IP blocked' : 'Access blocked (bot detection or geo-restriction)';
-        return new MCPSearXNGError(`🚫 ${target} Error (${status}): ${reason}`);
+        return new MCPSearXNGError(`🚫 ${target} Error (${status}): Access blocked (bot detection or geo-restriction)`);
     }
     if (status === 404) {
-        const reason = context.searxngUrl ? 'Search endpoint not found' : 'Page not found';
-        return new MCPSearXNGError(`🚫 ${target} Error (${status}): ${reason}`);
+        return new MCPSearXNGError(`🚫 ${target} Error (${status}): Page not found`);
     }
     if (status === 429) {
         return new MCPSearXNGError(`🚫 ${target} Error (${status}): Rate limit exceeded`);
@@ -56,15 +52,8 @@ export function createServerError(status, statusText, responseBody, context) {
     }
     return new MCPSearXNGError(`🚫 ${target} Error (${status}): ${statusText}`);
 }
-export function createJSONError(responseText, context) {
-    const preview = responseText.substring(0, 100).replace(/\n/g, ' ');
-    return new MCPSearXNGError(`🔍 SearXNG Response Error: Invalid JSON format. Response: "${preview}..."`);
-}
-export function createDataError(data, context) {
-    return new MCPSearXNGError(`🔍 SearXNG Data Error: Missing results array in response`);
-}
 export function createNoResultsMessage(query) {
-    return `🔍 No results found for "${query}". Try different search terms or check if SearXNG search engines are working.`;
+    return `🔍 No results found for "${query}". Try different search terms or check if the Gateway service is working.`;
 }
 export function createURLFormatError(url) {
     return new MCPSearXNGError(`🔧 URL Format Error: Invalid URL "${url}"`);
@@ -72,14 +61,11 @@ export function createURLFormatError(url) {
 export function createContentError(message, url) {
     return new MCPSearXNGError(`📄 Content Error: ${message} (${url})`);
 }
-export function createConversionError(error, url, htmlContent) {
-    return new MCPSearXNGError(`🔄 Conversion Error: Cannot convert HTML to Markdown (${url})`);
-}
 export function createTimeoutError(timeout, url) {
     const hostname = new URL(url).hostname;
     return new MCPSearXNGError(`⏱️ Timeout Error: ${hostname} took longer than ${timeout}ms to respond`);
 }
-export function createEmptyContentWarning(url, htmlLength, htmlPreview) {
+export function createEmptyContentWarning(url) {
     return `📄 Content Warning: Page fetched but appears empty after conversion (${url}). May contain only media or require JavaScript.`;
 }
 export function createUnexpectedError(error, context) {
@@ -87,28 +73,30 @@ export function createUnexpectedError(error, context) {
 }
 export function validateEnvironment() {
     const issues = [];
+    // Validate GATEWAY_URL if provided
     const gatewayUrl = process.env.GATEWAY_URL;
     if (gatewayUrl) {
         try {
             const url = new URL(gatewayUrl);
             if (!['http:', 'https:'].includes(url.protocol)) {
-                issues.push(`GATEWAY_URL invalid protocol: ${url.protocol}`);
+                issues.push(`GATEWAY_URL has invalid protocol: ${url.protocol}`);
             }
         }
-        catch (error) {
-            issues.push(`GATEWAY_URL invalid format: ${gatewayUrl}`);
+        catch {
+            issues.push(`GATEWAY_URL has invalid format: ${gatewayUrl}`);
         }
     }
-    const authUsername = process.env.AUTH_USERNAME;
-    const authPassword = process.env.AUTH_PASSWORD;
-    if (authUsername && !authPassword) {
-        issues.push("AUTH_USERNAME set but AUTH_PASSWORD missing");
+    // Validate auth credentials are paired correctly
+    const hasUsername = process.env.AUTH_USERNAME;
+    const hasPassword = process.env.AUTH_PASSWORD;
+    if (hasUsername && !hasPassword) {
+        issues.push("AUTH_USERNAME is set but AUTH_PASSWORD is missing");
     }
-    else if (!authUsername && authPassword) {
-        issues.push("AUTH_PASSWORD set but AUTH_USERNAME missing");
+    if (hasPassword && !hasUsername) {
+        issues.push("AUTH_PASSWORD is set but AUTH_USERNAME is missing");
     }
     if (issues.length === 0) {
         return null;
     }
-    return `⚠️ Configuration Issues: ${issues.join(', ')}. GATEWAY_URL is optional (defaults to http://115.190.91.253:80)`;
+    return `⚠️ Configuration Issues: ${issues.join(', ')}. GATEWAY_URL must be set to a valid HTTP(S) URL`;
 }

package/dist/index.d.ts

@@ -1,11 +1,3 @@
 #!/usr/bin/env node
-declare const packageVersion = "0.8.0";
+declare const packageVersion = "0.9.0";
 export { packageVersion };
-export declare function isWebUrlReadArgs(args: unknown): args is {
-    url: string;
-    startChar?: number;
-    maxLength?: number;
-    section?: string;
-    paragraphRange?: string;
-    readHeadings?: boolean;
-};

package/dist/index.js

@@ -3,51 +3,19 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 // Import modularized functionality
-import { WEB_SEARCH_TOOL, READ_URL_TOOL, isSearXNGWebSearchArgs } from "./types.js";
+import { IMAGE_GENERATE_TOOL, IMAGE_UNDERSTAND_TOOL, READ_URL_TOOL, WEB_SEARCH_TOOL, isImageGenerateArgs, isImageUnderstandArgs, isSearXNGWebSearchArgs, isWebUrlReadArgs, } from "./types.js";
 import { logMessage, setLogLevel } from "./logging.js";
 import { performWebSearch } from "./search.js";
 import { fetchAndConvertToMarkdown } from "./url-reader.js";
+import { understandImage } from "./tools/image-understand.js";
+import { generateImage } from "./tools/image-generate.js";
 import { createConfigResource, createHelpResource } from "./resources.js";
 import { createHttpServer } from "./http-server.js";
 import { validateEnvironment as validateEnv } from "./error-handler.js";
 // Use a static version string that will be updated by the version script
-const packageVersion = "0.8.0";
+const packageVersion = "0.9.0";
 // Export the version for use in other modules
 export { packageVersion };
-// Global state for logging level
-let currentLogLevel = "info";
-// Type guard for URL reading args
-export function isWebUrlReadArgs(args) {
-    if (typeof args !== "object" ||
-        args === null ||
-        !("url" in args) ||
-        typeof args.url !== "string") {
-        return false;
-    }
-    const urlArgs = args;
-    // Convert empty strings to undefined for optional string parameters
-    if (urlArgs.section === "")
-        urlArgs.section = undefined;
-    if (urlArgs.paragraphRange === "")
-        urlArgs.paragraphRange = undefined;
-    // Validate optional parameters
-    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;
-}
 // Server implementation
 const server = new Server({
     name: "ihor-sokoliuk/mcp-searxng",
@@ -65,59 +33,79 @@ const server = new Server({
                 description: READ_URL_TOOL.description,
                 schema: READ_URL_TOOL.inputSchema,
             },
+            image_understand: {
+                description: IMAGE_UNDERSTAND_TOOL.description,
+                schema: IMAGE_UNDERSTAND_TOOL.inputSchema,
+            },
+            image_generate: {
+                description: IMAGE_GENERATE_TOOL.description,
+                schema: IMAGE_GENERATE_TOOL.inputSchema,
+            },
         },
     },
 });
 // List tools handler
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+    resetActivityTimeout();
     logMessage(server, "debug", "Handling list_tools request");
     return {
-        tools: [WEB_SEARCH_TOOL, READ_URL_TOOL],
+        tools: [
+            WEB_SEARCH_TOOL,
+            READ_URL_TOOL,
+            IMAGE_UNDERSTAND_TOOL,
+            IMAGE_GENERATE_TOOL
+        ],
     };
 });
 // Call tool handler
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    resetActivityTimeout();
     const { name, arguments: args } = request.params;
     logMessage(server, "debug", `Handling call_tool request: ${name}`);
     try {
-        if (name === "searxng_web_search") {
-            if (!isSearXNGWebSearchArgs(args)) {
-                throw new Error("Invalid arguments for web search");
+        let result;
+        switch (name) {
+            case "searxng_web_search": {
+                if (!isSearXNGWebSearchArgs(args)) {
+                    throw new Error("Invalid arguments for web search");
+                }
+                result = await performWebSearch(server, args.query, args.limit);
+                break;
             }
-            const result = await performWebSearch(server, args.query, args.limit);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: result,
-                    },
-                ],
-            };
-        }
-        else if (name === "web_url_read") {
-            if (!isWebUrlReadArgs(args)) {
-                throw new Error("Invalid arguments for URL reading");
+            case "web_url_read": {
+                if (!isWebUrlReadArgs(args)) {
+                    throw new Error("Invalid arguments for URL reading");
+                }
+                // Use default 30s timeout (undefined) instead of hardcoded 10s
+                result = await fetchAndConvertToMarkdown(server, args.url, undefined, {
+                    startChar: args.startChar,
+                    maxLength: args.maxLength,
+                    section: args.section,
+                    paragraphRange: args.paragraphRange,
+                    readHeadings: args.readHeadings,
+                });
+                break;
             }
-            const paginationOptions = {
-                startChar: args.startChar,
-                maxLength: args.maxLength,
-                section: args.section,
-                paragraphRange: args.paragraphRange,
-                readHeadings: args.readHeadings,
-            };
-            const result = await fetchAndConvertToMarkdown(server, args.url, 10000, paginationOptions);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: result,
-                    },
-                ],
-            };
-        }
-        else {
-            throw new Error(`Unknown tool: ${name}`);
+            case "image_understand": {
+                if (!isImageUnderstandArgs(args)) {
+                    throw new Error("Invalid arguments for image understanding");
+                }
+                result = await understandImage(args);
+                break;
+            }
+            case "image_generate": {
+                if (!isImageGenerateArgs(args)) {
+                    throw new Error("Invalid arguments for image generation");
+                }
+                result = await generateImage(args);
+                break;
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
         }
+        return {
+            content: [{ type: "text", text: result }],
+        };
     }
     catch (error) {
         logMessage(server, "error", `Tool execution error: ${error instanceof Error ? error.message : String(error)}`, {
@@ -130,14 +118,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 // Logging level handler
 server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    resetActivityTimeout();
     const { level } = request.params;
     logMessage(server, "info", `Setting log level to: ${level}`);
-    currentLogLevel = level;
     setLogLevel(level);
     return {};
 });
 // List resources handler
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    resetActivityTimeout();
     logMessage(server, "debug", "Handling list_resources request");
     return {
         resources: [
@@ -158,6 +147,7 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
 });
 // Read resource handler
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    resetActivityTimeout();
     const { uri } = request.params;
     logMessage(server, "debug", `Handling read_resource request for: ${uri}`);
     switch (uri) {
@@ -185,6 +175,45 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             throw new Error(`Unknown resource: ${uri}`);
     }
 });
+// Inactivity timeout: shut down after 3 minutes of no client requests
+const INACTIVITY_TIMEOUT_MS = 180000; // 3 minutes
+let activityTimeout;
+/**
+ * Reset the inactivity timer. Called on every MCP request.
+ * If no request occurs within the timeout period, the server exits.
+ */
+function resetActivityTimeout() {
+    clearTimeout(activityTimeout);
+    activityTimeout = setTimeout(() => {
+        logMessage(server, "info", `No activity for ${INACTIVITY_TIMEOUT_MS / 1000}s, shutting down`);
+        process.exit(0);
+    }, INACTIVITY_TIMEOUT_MS);
+}
+// Shutdown configuration
+const SHUTDOWN_TIMEOUT_MS = 10000;
+function setupShutdownHandlers(mode, httpServer) {
+    const shutdown = (signal) => {
+        clearTimeout(activityTimeout);
+        const logFn = mode === 'http' ? console.log : (msg) => logMessage(server, 'info', msg);
+        logFn(`Received ${signal}. Shutting down ${mode.toUpperCase()} server...`);
+        if (mode === 'http' && httpServer) {
+            const timeoutId = setTimeout(() => {
+                console.error('Forced shutdown after timeout');
+                process.exit(1);
+            }, SHUTDOWN_TIMEOUT_MS);
+            httpServer.close(() => {
+                clearTimeout(timeoutId);
+                console.log('HTTP server closed');
+                process.exit(0);
+            });
+        }
+        else {
+            process.exit(0);
+        }
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
 // Main function
 async function main() {
     // Environment validation
@@ -193,14 +222,20 @@ async function main() {
         console.error(`❌ ${validationError}`);
         process.exit(1);
     }
+    // Validate Zhipu AI (warning only, don't block startup)
+    if (!process.env.ZHIPUAI_API_KEY) {
+        console.warn('WARNING: ZHIPUAI_API_KEY not set. Image tools will not work.');
+    }
     // Check for HTTP transport mode
     const httpPort = process.env.MCP_HTTP_PORT;
+    const gatewayUrlDisplay = process.env.GATEWAY_URL || "Not configured (required)";
     if (httpPort) {
         const port = parseInt(httpPort, 10);
         if (isNaN(port) || port < 1 || port > 65535) {
             console.error(`Invalid HTTP port: ${httpPort}. Must be between 1-65535.`);
             process.exit(1);
         }
+        console.log(`GATEWAY_URL: ${gatewayUrlDisplay}`);
         console.log(`Starting HTTP transport on port ${port}`);
         const app = await createHttpServer(server);
         const httpServer = app.listen(port, () => {
@@ -208,16 +243,7 @@ async function main() {
             console.log(`Health check: http://localhost:${port}/health`);
             console.log(`MCP endpoint: http://localhost:${port}/mcp`);
         });
-        // Handle graceful shutdown
-        const shutdown = (signal) => {
-            console.log(`Received ${signal}. Shutting down HTTP server...`);
-            httpServer.close(() => {
-                console.log("HTTP server closed");
-                process.exit(0);
-            });
-        };
-        process.on('SIGINT', () => shutdown('SIGINT'));
-        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        setupShutdownHandlers('http', httpServer);
     }
     else {
         // Default STDIO transport
@@ -225,16 +251,27 @@ async function main() {
         if (process.stdin.isTTY) {
             console.log(`🔍 MCP SearXNG Server v${packageVersion} - Ready`);
             console.log("✅ Configuration valid");
-            console.log(`🌐 Gateway URL: ${process.env.GATEWAY_URL || "http://115.190.91.253:80 (default)"}`);
+            console.log(`🌐 Gateway URL: ${gatewayUrlDisplay}`);
             console.log("📡 Waiting for MCP client connection via STDIO...\n");
         }
         const transport = new StdioServerTransport();
+        // Handle stdin close (when client disconnects)
+        const handleStdioClose = () => {
+            clearTimeout(activityTimeout);
+            logMessage(server, "info", "STDIO connection closed by client");
+            transport.close().then(() => process.exit(0));
+        };
+        // Listen for both stdin close and transport close
+        process.stdin.on('close', handleStdioClose);
+        transport.onclose = handleStdioClose;
         await server.connect(transport);
+        // Start inactivity timer after connection
+        resetActivityTimeout();
         // Log after connection is established
         logMessage(server, "info", `MCP SearXNG Server v${packageVersion} connected via STDIO`);
-        logMessage(server, "info", `Log level: ${currentLogLevel}`);
         logMessage(server, "info", `Environment: ${process.env.NODE_ENV || 'development'}`);
-        logMessage(server, "info", `Gateway URL: ${process.env.GATEWAY_URL || 'http://115.190.91.253:80 (default)'}`);
+        logMessage(server, "info", `Gateway URL: ${gatewayUrlDisplay}`);
+        setupShutdownHandlers('stdio');
     }
 }
 // Handle uncaught errors