@amplify-studio/open-mcp 0.8.0

package/dist/index.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+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 { logMessage, setLogLevel } from "./logging.js";
+import { performWebSearch } from "./search.js";
+import { fetchAndConvertToMarkdown } from "./url-reader.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";
+// 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",
+    version: packageVersion,
+}, {
+    capabilities: {
+        logging: {},
+        resources: {},
+        tools: {
+            searxng_web_search: {
+                description: WEB_SEARCH_TOOL.description,
+                schema: WEB_SEARCH_TOOL.inputSchema,
+            },
+            web_url_read: {
+                description: READ_URL_TOOL.description,
+                schema: READ_URL_TOOL.inputSchema,
+            },
+        },
+    },
+});
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logMessage(server, "debug", "Handling list_tools request");
+    return {
+        tools: [WEB_SEARCH_TOOL, READ_URL_TOOL],
+    };
+});
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    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");
+            }
+            const result = await performWebSearch(server, args.query, args.pageno, args.time_range, args.language, args.safesearch);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        else if (name === "web_url_read") {
+            if (!isWebUrlReadArgs(args)) {
+                throw new Error("Invalid arguments for URL reading");
+            }
+            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}`);
+        }
+    }
+    catch (error) {
+        logMessage(server, "error", `Tool execution error: ${error instanceof Error ? error.message : String(error)}`, {
+            tool: name,
+            args: args,
+            error: error instanceof Error ? error.stack : String(error)
+        });
+        throw error;
+    }
+});
+// Logging level handler
+server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    const { level } = request.params;
+    logMessage(server, "info", `Setting log level to: ${level}`);
+    currentLogLevel = level;
+    setLogLevel(level);
+    return {};
+});
+// List resources handler
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logMessage(server, "debug", "Handling list_resources request");
+    return {
+        resources: [
+            {
+                uri: "config://server-config",
+                mimeType: "application/json",
+                name: "Server Configuration",
+                description: "Current server configuration and environment variables"
+            },
+            {
+                uri: "help://usage-guide",
+                mimeType: "text/markdown",
+                name: "Usage Guide",
+                description: "How to use the MCP SearXNG server effectively"
+            }
+        ]
+    };
+});
+// Read resource handler
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logMessage(server, "debug", `Handling read_resource request for: ${uri}`);
+    switch (uri) {
+        case "config://server-config":
+            return {
+                contents: [
+                    {
+                        uri: uri,
+                        mimeType: "application/json",
+                        text: createConfigResource()
+                    }
+                ]
+            };
+        case "help://usage-guide":
+            return {
+                contents: [
+                    {
+                        uri: uri,
+                        mimeType: "text/markdown",
+                        text: createHelpResource()
+                    }
+                ]
+            };
+        default:
+            throw new Error(`Unknown resource: ${uri}`);
+    }
+});
+// Main function
+async function main() {
+    // Environment validation
+    const validationError = validateEnv();
+    if (validationError) {
+        console.error(`❌ ${validationError}`);
+        process.exit(1);
+    }
+    // Check for HTTP transport mode
+    const httpPort = process.env.MCP_HTTP_PORT;
+    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(`Starting HTTP transport on port ${port}`);
+        const app = await createHttpServer(server);
+        const httpServer = app.listen(port, () => {
+            console.log(`HTTP server listening on port ${port}`);
+            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'));
+    }
+    else {
+        // Default STDIO transport
+        // Show helpful message when running in terminal
+        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("📡 Waiting for MCP client connection via STDIO...\n");
+        }
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        // 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)'}`);
+    }
+}
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    process.exit(1);
+});
+// Start the server (CLI entrypoint)
+main().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+});

package/dist/logging.d.ts

@@ -0,0 +1,6 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { LoggingLevel } from "@modelcontextprotocol/sdk/types.js";
+export declare function logMessage(server: Server, level: LoggingLevel, message: string, data?: unknown): void;
+export declare function shouldLog(level: LoggingLevel): boolean;
+export declare function setLogLevel(level: LoggingLevel): void;
+export declare function getCurrentLogLevel(): LoggingLevel;

package/dist/logging.js

@@ -0,0 +1,42 @@
+// Logging state
+let currentLogLevel = "info";
+// Logging helper function
+export function logMessage(server, level, message, data) {
+    if (shouldLog(level)) {
+        try {
+            // Merge message and data together for the notification body
+            const notificationData = data !== undefined
+                ? (typeof data === 'object' && data !== null ? { message, ...data } : { message, data })
+                : { message };
+            server.notification({
+                method: "notifications/message",
+                params: {
+                    level,
+                    data: notificationData
+                }
+            }).catch((error) => {
+                // Silently ignore "Not connected" errors during server startup
+                // This can happen when logging occurs before the transport is fully connected
+                if (error instanceof Error && error.message !== "Not connected") {
+                    console.error("Logging error:", error);
+                }
+            });
+        }
+        catch (error) {
+            // Handle synchronous errors as well
+            if (error instanceof Error && error.message !== "Not connected") {
+                console.error("Logging error:", error);
+            }
+        }
+    }
+}
+export function shouldLog(level) {
+    const levels = ["debug", "info", "warning", "error"];
+    return levels.indexOf(level) >= levels.indexOf(currentLogLevel);
+}
+export function setLogLevel(level) {
+    currentLogLevel = level;
+}
+export function getCurrentLogLevel() {
+    return currentLogLevel;
+}

package/dist/proxy.d.ts

@@ -0,0 +1,16 @@
+import { ProxyAgent } from "undici";
+/**
+ * Creates a proxy agent dispatcher for Node.js fetch API.
+ *
+ * Node.js fetch uses Undici under the hood, which requires a 'dispatcher' option
+ * instead of 'agent'. This function creates a ProxyAgent compatible with fetch.
+ *
+ * Environment variables checked (in order):
+ * - HTTP_PROXY / http_proxy: For HTTP requests
+ * - HTTPS_PROXY / https_proxy: For HTTPS requests
+ * - NO_PROXY / no_proxy: Comma-separated list of hosts to bypass proxy
+ *
+ * @param targetUrl - Optional target URL to check against NO_PROXY rules
+ * @returns ProxyAgent dispatcher for fetch, or undefined if no proxy configured or bypassed
+ */
+export declare function createProxyAgent(targetUrl?: string): ProxyAgent | undefined;

package/dist/proxy.js

@@ -0,0 +1,97 @@
+import { ProxyAgent } from "undici";
+/**
+ * Checks if a target URL should bypass the proxy based on NO_PROXY environment variable.
+ *
+ * @param targetUrl - The URL to check against NO_PROXY rules
+ * @returns true if the URL should bypass the proxy, false otherwise
+ */
+function shouldBypassProxy(targetUrl) {
+    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+    if (!noProxy) {
+        return false;
+    }
+    // Wildcard bypass
+    if (noProxy.trim() === '*') {
+        return true;
+    }
+    let hostname;
+    try {
+        const url = new URL(targetUrl);
+        hostname = url.hostname.toLowerCase();
+    }
+    catch (error) {
+        // Invalid URL, don't bypass
+        return false;
+    }
+    // Parse comma-separated list of bypass patterns
+    const bypassPatterns = noProxy.split(',').map(pattern => pattern.trim().toLowerCase());
+    for (const pattern of bypassPatterns) {
+        if (!pattern)
+            continue;
+        // Exact hostname match
+        if (hostname === pattern) {
+            return true;
+        }
+        // Domain suffix match with leading dot (e.g., .example.com matches sub.example.com)
+        if (pattern.startsWith('.') && hostname.endsWith(pattern)) {
+            return true;
+        }
+        // Domain suffix match without leading dot (e.g., example.com matches sub.example.com and example.com)
+        if (!pattern.startsWith('.')) {
+            // Exact match
+            if (hostname === pattern) {
+                return true;
+            }
+            // Subdomain match
+            if (hostname.endsWith(`.${pattern}`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Creates a proxy agent dispatcher for Node.js fetch API.
+ *
+ * Node.js fetch uses Undici under the hood, which requires a 'dispatcher' option
+ * instead of 'agent'. This function creates a ProxyAgent compatible with fetch.
+ *
+ * Environment variables checked (in order):
+ * - HTTP_PROXY / http_proxy: For HTTP requests
+ * - HTTPS_PROXY / https_proxy: For HTTPS requests
+ * - NO_PROXY / no_proxy: Comma-separated list of hosts to bypass proxy
+ *
+ * @param targetUrl - Optional target URL to check against NO_PROXY rules
+ * @returns ProxyAgent dispatcher for fetch, or undefined if no proxy configured or bypassed
+ */
+export function createProxyAgent(targetUrl) {
+    const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy;
+    if (!proxyUrl) {
+        return undefined;
+    }
+    // Check if target URL should bypass proxy
+    if (targetUrl && shouldBypassProxy(targetUrl)) {
+        return undefined;
+    }
+    // Validate and normalize proxy URL
+    let parsedProxyUrl;
+    try {
+        parsedProxyUrl = new URL(proxyUrl);
+    }
+    catch (error) {
+        throw new Error(`Invalid proxy URL: ${proxyUrl}. ` +
+            "Please provide a valid URL (e.g., http://proxy:8080 or http://user:pass@proxy:8080)");
+    }
+    // Ensure proxy protocol is supported
+    if (!['http:', 'https:'].includes(parsedProxyUrl.protocol)) {
+        throw new Error(`Unsupported proxy protocol: ${parsedProxyUrl.protocol}. ` +
+            "Only HTTP and HTTPS proxies are supported.");
+    }
+    // Reconstruct base proxy URL preserving credentials
+    const auth = parsedProxyUrl.username ?
+        (parsedProxyUrl.password ? `${parsedProxyUrl.username}:${parsedProxyUrl.password}@` : `${parsedProxyUrl.username}@`) :
+        '';
+    const normalizedProxyUrl = `${parsedProxyUrl.protocol}//${auth}${parsedProxyUrl.host}`;
+    // Create and return Undici ProxyAgent compatible with fetch's dispatcher option
+    return new ProxyAgent(normalizedProxyUrl);
+}

package/dist/resources.d.ts

@@ -0,0 +1,2 @@
+export declare function createConfigResource(): string;
+export declare function createHelpResource(): string;

package/dist/resources.js

@@ -0,0 +1,95 @@
+import { getCurrentLogLevel } from "./logging.js";
+import { packageVersion } from "./index.js";
+export function createConfigResource() {
+    const config = {
+        serverInfo: {
+            name: "ihor-sokoliuk/mcp-searxng",
+            version: packageVersion,
+            description: "MCP server for SearXNG integration via Gateway API"
+        },
+        environment: {
+            gatewayUrl: process.env.GATEWAY_URL || "http://115.190.91.253:80 (default)",
+            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"],
+            logging: true,
+            resources: true,
+            transports: process.env.MCP_HTTP_PORT ? ["stdio", "http"] : ["stdio"]
+        }
+    };
+    return JSON.stringify(config, null, 2);
+}
+export function createHelpResource() {
+    return `# SearXNG MCP Server Help
+
+## Overview
+This is a Model Context Protocol (MCP) server that provides web search capabilities through a Gateway API and URL content reading functionality.
+
+## Available Tools
+
+### 1. searxng_web_search
+Performs web searches using the configured Gateway API.
+
+**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)
+
+### 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
+
+## Configuration
+
+### Optional Environment Variables
+- \`GATEWAY_URL\`: URL of the Gateway API (default: http://115.190.91.253:80)
+
+### Optional Environment Variables
+- \`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
+
+### STDIO (Default)
+Standard input/output transport for desktop clients like Claude Desktop.
+
+### HTTP (Optional)
+RESTful HTTP transport for web applications. Set \`MCP_HTTP_PORT\` to enable.
+
+## Usage Examples
+
+### Search for recent news
+\`\`\`
+Tool: searxng_web_search
+Args: {"query": "latest AI developments", "time_range": "day"}
+\`\`\`
+
+### Read a specific article
+\`\`\`
+Tool: web_url_read
+Args: {"url": "https://example.com/article"}
+\`\`\`
+
+## 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
+
+Use logging level "debug" for detailed request information.
+
+## Current Configuration
+See the "Current Configuration" resource for live settings.
+`;
+}

package/dist/search.d.ts

@@ -0,0 +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>;

package/dist/search.js

@@ -0,0 +1,130 @@
+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) {
+    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);
+    }
+    if (language && language !== "all") {
+        url.searchParams.set("language", language);
+    }
+    if (safesearch !== undefined && ["0", "1", "2"].includes(safesearch)) {
+        url.searchParams.set("safesearch", safesearch);
+    }
+    // Prepare request options with headers
+    const requestOptions = {
+        method: "GET"
+    };
+    // 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
+    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}`
+        };
+    }
+    // Add User-Agent header if configured
+    const userAgent = process.env.USER_AGENT;
+    if (userAgent) {
+        requestOptions.headers = {
+            ...requestOptions.headers,
+            'User-Agent': userAgent
+        };
+    }
+    // Fetch with enhanced error handling
+    let response;
+    try {
+        logMessage(server, "info", `Making request to: ${url.toString()}`);
+        response = await fetch(url.toString(), requestOptions);
+    }
+    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);
+    }
+    if (!response.ok) {
+        let responseBody;
+        try {
+            responseBody = await response.text();
+        }
+        catch {
+            responseBody = '[Could not read response body]';
+        }
+        const context = {
+            url: url.toString(),
+            gatewayUrl
+        };
+        throw createServerError(response.status, response.statusText, responseBody, context);
+    }
+    // Parse JSON response
+    let data;
+    try {
+        data = (await response.json());
+    }
+    catch (error) {
+        let responseText;
+        try {
+            responseText = await response.text();
+        }
+        catch {
+            responseText = '[Could not read response text]';
+        }
+        const context = { url: url.toString() };
+        throw createJSONError(responseText, context);
+    }
+    if (!data.results) {
+        const context = { url: url.toString(), query };
+        throw createDataError(data, context);
+    }
+    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);
+    }
+    const duration = Date.now() - startTime;
+    logMessage(server, "info", `Search completed: "${query}" (${searchParams}) - ${results.length} results in ${duration}ms`);
+    return results
+        .map((r) => `Title: ${r.title}\nDescription: ${r.content}\nURL: ${r.url}\nRelevance Score: ${r.score.toFixed(3)}`)
+        .join("\n\n");
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+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;
+};
+export declare const WEB_SEARCH_TOOL: Tool;
+export declare const READ_URL_TOOL: Tool;