@lmcc-dev/mult-fetch-mcp-server 1.2.0 → 1.3.0

package/dist/src/lib/server/fetcher.js

@@ -6,6 +6,7 @@
 import { Fetcher } from '../fetch.js';
 import { log, COMPONENTS } from '../logger.js';
 import { initializeBrowser, closeBrowserInstance, shouldSwitchToBrowser } from './browser.js';
+import { BaseFetcher } from '../fetchers/common/BaseFetcher.js';
 /**
  * 辅助函数：根据类型和参数自动选择合适的获取方法 (Helper function: automatically select appropriate fetching method based on type and parameters)
  * 支持自动在标准模式和浏览器模式之间切换 (Supports automatic switching between standard mode and browser mode)
@@ -38,6 +39,10 @@ export async function fetchWithAutoDetect(params, type) {
                     return await Fetcher.txt(params);
                 case 'markdown':
                     return await Fetcher.markdown(params);
+                case 'plaintext':
+                    return await Fetcher.plainText(params);
+                default:
+                    throw new Error(`Unsupported content type: ${type}`);
             }
         }
         else {
@@ -47,43 +52,122 @@ export async function fetchWithAutoDetect(params, type) {
             }
             try {
                 // 根据类型选择合适的标准获取方法 (Choose appropriate standard fetching method based on type)
+                let result;
                 switch (type) {
                     case 'html': {
-                        return await Fetcher.html(params);
+                        result = await Fetcher.html(params);
+                        break;
                     }
                     case 'json': {
-                        return await Fetcher.json(params);
+                        result = await Fetcher.json(params);
+                        break;
                     }
                     case 'txt': {
-                        return await Fetcher.txt(params);
+                        result = await Fetcher.txt(params);
+                        break;
                     }
                     case 'markdown': {
-                        return await Fetcher.markdown(params);
+                        result = await Fetcher.markdown(params);
+                        break;
+                    }
+                    case 'plaintext': {
+                        result = await Fetcher.plainText(params);
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unsupported content type: ${type}`);
+                }
+                // 检查结果是否为错误，并且是否包含403或forbidden关键词
+                if (result.isError && autoDetectMode) {
+                    const errorText = result.content && result.content[0] && result.content[0].text
+                        ? String(result.content[0].text)
+                        : '';
+                    const is403Error = errorText.includes('403') ||
+                        errorText.toLowerCase().includes('forbidden');
+                    if (is403Error || shouldSwitchToBrowser(errorText)) {
+                        if (debug) {
+                            log('server.switchingToBrowserMode', debug, {
+                                url: params.url,
+                                error: errorText,
+                                reason: is403Error ? '403 Forbidden' : 'Other error requiring browser'
+                            }, COMPONENTS.SERVER);
+                        }
+                        // 确保浏览器已初始化
+                        await initializeBrowser(debug);
+                        // 设置浏览器模式参数
+                        const browserParams = {
+                            ...params,
+                            useBrowser: true,
+                            debug: debug
+                        };
+                        // 根据类型选择合适的浏览器获取方法
+                        let browserResult;
+                        switch (type) {
+                            case 'html':
+                                browserResult = await Fetcher.html(browserParams);
+                                break;
+                            case 'json':
+                                browserResult = await Fetcher.json(browserParams);
+                                break;
+                            case 'txt':
+                                browserResult = await Fetcher.txt(browserParams);
+                                break;
+                            case 'markdown':
+                                browserResult = await Fetcher.markdown(browserParams);
+                                break;
+                            case 'plaintext':
+                                browserResult = await Fetcher.plainText(browserParams);
+                                break;
+                            default:
+                                throw new Error(`Unsupported content type: ${type}`);
+                        }
+                        return browserResult;
                     }
                 }
+                return result;
             }
             catch (error) {
                 // 如果标准模式失败且启用了自动检测
-                if (autoDetectMode && shouldSwitchToBrowser(error)) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // 检查是否应该切换到浏览器模式
+                // 特别处理 HTTP 403 Forbidden 错误，这是最常见的需要切换到浏览器模式的情况
+                const shouldSwitch = autoDetectMode && (shouldSwitchToBrowser(error) ||
+                    errorMessage.includes('403') ||
+                    errorMessage.toLowerCase().includes('forbidden'));
+                if (shouldSwitch) {
                     if (debug) {
                         log('server.switchingToBrowserMode', debug, { url: params.url }, COMPONENTS.SERVER);
                     }
                     // 确保浏览器已初始化
                     await initializeBrowser(debug);
                     // 设置浏览器模式参数
-                    params.useBrowser = true;
-                    params.debug = debug;
+                    const browserParams = {
+                        ...params,
+                        useBrowser: true,
+                        debug: debug
+                    };
                     // 根据类型选择合适的浏览器获取方法
+                    let browserResult;
                     switch (type) {
                         case 'html':
-                            return await Fetcher.html(params);
+                            browserResult = await Fetcher.html(browserParams);
+                            break;
                         case 'json':
-                            return await Fetcher.json(params);
+                            browserResult = await Fetcher.json(browserParams);
+                            break;
                         case 'txt':
-                            return await Fetcher.txt(params);
+                            browserResult = await Fetcher.txt(browserParams);
+                            break;
                         case 'markdown':
-                            return await Fetcher.markdown(params);
+                            browserResult = await Fetcher.markdown(browserParams);
+                            break;
+                        case 'plaintext':
+                            browserResult = await Fetcher.plainText(browserParams);
+                            break;
+                        default:
+                            throw new Error(`Unsupported content type: ${type}`);
                     }
+                    return browserResult;
                 }
                 // 如果不需要切换到浏览器模式，则抛出原始错误
                 throw error;
@@ -102,8 +186,5 @@ export async function fetchWithAutoDetect(params, type) {
         throw error;
     }
     // 如果没有匹配的类型，返回错误
-    return {
-        content: [{ type: 'text', text: `Unsupported content type: ${type}` }],
-        isError: true
-    };
+    return BaseFetcher.createErrorResponse(`Unsupported content type: ${type}`);
 }

package/dist/src/lib/server/tools.js

@@ -7,6 +7,8 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { log, COMPONENTS } from '../logger.js';
 import { fetchWithAutoDetect } from './fetcher.js';
 import { closeBrowserInstance } from './browser.js';
+import { BaseFetcher } from '../fetchers/common/BaseFetcher.js';
+import { TemplateUtils } from '../utils/TemplateUtils.js';
 /**
  * 获取HTML获取工具定义 (Get HTML fetch tool definition)
  * @returns HTML获取工具定义 (HTML fetch tool definition)
@@ -14,7 +16,7 @@ import { closeBrowserInstance } from './browser.js';
 function getHtmlFetchToolDefinition() {
     return {
         name: "fetch_html",
-        description: "Fetch a website and return the content as HTML",
+        description: "Fetch a website and return the content as HTML. Best practices: 1) Always set startCursor=0 for initial requests, and use the fetchedBytes value from previous response for subsequent requests to ensure content continuity. 2) Set contentSizeLimit between 20000-50000 for large pages. 3) When handling large content, use the chunking system by following the startCursor instructions in the system notes rather than increasing contentSizeLimit. 4) If content retrieval fails, you can retry using the same chunkId and startCursor, or adjust startCursor as needed but you must handle any resulting data duplication or gaps yourself. 5) Always explain to users when content is chunked and ask if they want to continue retrieving subsequent parts.",
         inputSchema: {
             type: "object",
             properties: {
@@ -22,6 +24,10 @@ function getHtmlFetchToolDefinition() {
                     type: "string",
                     description: "URL of the website to fetch",
                 },
+                startCursor: {
+                    type: "number",
+                    description: "Starting cursor position in bytes. Set to 0 for initial requests, and use the value from previous responses for subsequent requests to resume content retrieval.",
+                },
                 headers: {
                     type: "object",
                     description: "Optional headers to include in the request",
@@ -56,7 +62,7 @@ function getHtmlFetchToolDefinition() {
                 },
                 autoDetectMode: {
                     type: "boolean",
-                    description: "Optional flag to automatically switch to browser mode if standard fetch fails (default: true)",
+                    description: "Optional flag to automatically switch to browser mode if standard fetch fails (default: true). Set to false to strictly use the specified mode without automatic switching.",
                 },
                 waitForSelector: {
                     type: "string",
@@ -78,8 +84,20 @@ function getHtmlFetchToolDefinition() {
                     type: "boolean",
                     description: "Optional flag to close the browser after fetching (default: false)",
                 },
+                contentSizeLimit: {
+                    type: "number",
+                    description: "Optional maximum content size in bytes before splitting into chunks (default: 50KB). Set between 20KB-50KB for optimal results. For large content, prefer smaller values (20KB-30KB) to avoid truncation.",
+                },
+                enableContentSplitting: {
+                    type: "boolean",
+                    description: "Optional flag to enable content splitting for large responses (default: true)",
+                },
+                chunkId: {
+                    type: "string",
+                    description: `Optional chunk ID for retrieving a specific chunk of content from a previous request. The system adds prompts in the format ${TemplateUtils.SYSTEM_NOTE.START} ... ${TemplateUtils.SYSTEM_NOTE.END} which AI models should ignore when processing the content.`,
+                },
             },
-            required: ["url"],
+            required: ["url", "startCursor"],
         },
     };
 }
@@ -90,7 +108,7 @@ function getHtmlFetchToolDefinition() {
 function getJsonFetchToolDefinition() {
     return {
         name: "fetch_json",
-        description: "Fetch a JSON file from a URL",
+        description: "Fetch a JSON file from a URL. Best practices: 1) Always set startCursor=0 for initial requests, and use the fetchedBytes value from previous response for subsequent requests to ensure content continuity. 2) Set contentSizeLimit between 20000-50000 for large files. 3) When handling large content, use the chunking system by following the startCursor instructions in the system notes rather than increasing contentSizeLimit. 4) If content retrieval fails, you can retry using the same chunkId and startCursor, or adjust startCursor as needed but you must handle any resulting data duplication or gaps yourself. 5) Always explain to users when content is chunked and ask if they want to continue retrieving subsequent parts.",
         inputSchema: {
             type: "object",
             properties: {
@@ -98,6 +116,10 @@ function getJsonFetchToolDefinition() {
                     type: "string",
                     description: "URL of the JSON to fetch",
                 },
+                startCursor: {
+                    type: "number",
+                    description: "Starting cursor position in bytes. Set to 0 for initial requests, and use the value from previous responses for subsequent requests to resume content retrieval.",
+                },
                 headers: {
                     type: "object",
                     description: "Optional headers to include in the request",
@@ -142,8 +164,20 @@ function getJsonFetchToolDefinition() {
                     type: "boolean",
                     description: "Optional flag to close the browser after fetching (default: false)",
                 },
+                contentSizeLimit: {
+                    type: "number",
+                    description: "Optional maximum content size in bytes before splitting into chunks (default: 50KB). Set between 20KB-50KB for optimal results. For large content, prefer smaller values (20KB-30KB) to avoid truncation.",
+                },
+                enableContentSplitting: {
+                    type: "boolean",
+                    description: "Optional flag to enable content splitting for large responses (default: true)",
+                },
+                chunkId: {
+                    type: "string",
+                    description: `Optional chunk ID for retrieving a specific chunk of content from a previous request. The system adds prompts in the format ${TemplateUtils.SYSTEM_NOTE.START} ... ${TemplateUtils.SYSTEM_NOTE.END} which AI models should ignore when processing the content.`,
+                },
             },
-            required: ["url"],
+            required: ["url", "startCursor"],
         },
     };
 }
@@ -154,7 +188,7 @@ function getJsonFetchToolDefinition() {
 function getTextFetchToolDefinition() {
     return {
         name: "fetch_txt",
-        description: "Fetch a website, return the content as plain text (no HTML)",
+        description: "Fetch a website, return the content as plain text (no HTML). Best practices: 1) Always set startCursor=0 for initial requests, and use the fetchedBytes value from previous response for subsequent requests to ensure content continuity. 2) Set contentSizeLimit between 20000-50000 for large pages. 3) When handling large content, use the chunking system by following the startCursor instructions in the system notes rather than increasing contentSizeLimit. 4) If content retrieval fails, you can retry using the same chunkId and startCursor, or adjust startCursor as needed but you must handle any resulting data duplication or gaps yourself. 5) Always explain to users when content is chunked and ask if they want to continue retrieving subsequent parts.",
         inputSchema: {
             type: "object",
             properties: {
@@ -162,6 +196,10 @@ function getTextFetchToolDefinition() {
                     type: "string",
                     description: "URL of the website to fetch",
                 },
+                startCursor: {
+                    type: "number",
+                    description: "Starting cursor position in bytes. Set to 0 for initial requests, and use the value from previous responses for subsequent requests to resume content retrieval.",
+                },
                 headers: {
                     type: "object",
                     description: "Optional headers to include in the request",
@@ -206,8 +244,20 @@ function getTextFetchToolDefinition() {
                     type: "boolean",
                     description: "Optional flag to scroll to bottom of page in browser mode (default: false)",
                 },
+                contentSizeLimit: {
+                    type: "number",
+                    description: "Optional maximum content size in bytes before splitting into chunks (default: 50KB). Set between 20KB-50KB for optimal results. For large content, prefer smaller values (20KB-30KB) to avoid truncation.",
+                },
+                enableContentSplitting: {
+                    type: "boolean",
+                    description: "Optional flag to enable content splitting for large responses (default: true)",
+                },
+                chunkId: {
+                    type: "string",
+                    description: `Optional chunk ID for retrieving a specific chunk of content from a previous request. The system adds prompts in the format ${TemplateUtils.SYSTEM_NOTE.START} ... ${TemplateUtils.SYSTEM_NOTE.END} which AI models should ignore when processing the content.`,
+                },
             },
-            required: ["url"],
+            required: ["url", "startCursor"],
         },
     };
 }
@@ -218,7 +268,7 @@ function getTextFetchToolDefinition() {
 function getMarkdownFetchToolDefinition() {
     return {
         name: "fetch_markdown",
-        description: "Fetch a website and return the content as Markdown",
+        description: "Fetch a website and return the content as Markdown. Best practices: 1) Always set startCursor=0 for initial requests, and use the fetchedBytes value from previous response for subsequent requests to ensure content continuity. 2) Set contentSizeLimit between 20000-50000 for large pages. 3) When handling large content, use the chunking system by following the startCursor instructions in the system notes rather than increasing contentSizeLimit. 4) If content retrieval fails, you can retry using the same chunkId and startCursor, or adjust startCursor as needed but you must handle any resulting data duplication or gaps yourself. 5) Always explain to users when content is chunked and ask if they want to continue retrieving subsequent parts.",
         inputSchema: {
             type: "object",
             properties: {
@@ -226,6 +276,10 @@ function getMarkdownFetchToolDefinition() {
                     type: "string",
                     description: "URL of the website to fetch",
                 },
+                startCursor: {
+                    type: "number",
+                    description: "Starting cursor position in bytes. Set to 0 for initial requests, and use the value from previous responses for subsequent requests to resume content retrieval.",
+                },
                 headers: {
                     type: "object",
                     description: "Optional headers to include in the request",
@@ -270,8 +324,112 @@ function getMarkdownFetchToolDefinition() {
                     type: "boolean",
                     description: "Optional flag to scroll to bottom of page in browser mode (default: false)",
                 },
+                contentSizeLimit: {
+                    type: "number",
+                    description: "Optional maximum content size in bytes before splitting into chunks (default: 50KB). Set between 20KB-50KB for optimal results. For large content, prefer smaller values (20KB-30KB) to avoid truncation.",
+                },
+                enableContentSplitting: {
+                    type: "boolean",
+                    description: "Optional flag to enable content splitting for large responses (default: true)",
+                },
+                chunkId: {
+                    type: "string",
+                    description: `Optional chunk ID for retrieving a specific chunk of content from a previous request. The system adds prompts in the format ${TemplateUtils.SYSTEM_NOTE.START} ... ${TemplateUtils.SYSTEM_NOTE.END} which AI models should ignore when processing the content.`,
+                },
+            },
+            required: ["url", "startCursor"],
+        },
+    };
+}
+/**
+ * 获取纯文本获取工具定义 (Get plain text fetch tool definition)
+ * @returns 纯文本获取工具定义 (Plain text fetch tool definition)
+ */
+function getPlainTextFetchToolDefinition() {
+    return {
+        name: "fetch_plaintext",
+        description: "Fetch a website and return the content as plain text with HTML tags removed. Best practices: 1) Always set startCursor=0 for initial requests, and use the fetchedBytes value from previous response for subsequent requests to ensure content continuity. 2) Set contentSizeLimit between 20000-50000 for large pages. 3) When handling large content, use the chunking system by following the startCursor instructions in the system notes rather than increasing contentSizeLimit. 4) If content retrieval fails, you can retry using the same chunkId and startCursor, or adjust startCursor as needed but you must handle any resulting data duplication or gaps yourself. 5) Always explain to users when content is chunked and ask if they want to continue retrieving subsequent parts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL of the website to fetch",
+                },
+                startCursor: {
+                    type: "number",
+                    description: "Starting cursor position in bytes. Set to 0 for initial requests, and use the value from previous responses for subsequent requests to resume content retrieval.",
+                },
+                headers: {
+                    type: "object",
+                    description: "Optional headers to include in the request",
+                },
+                proxy: {
+                    type: "string",
+                    description: "Optional proxy server to use (format: http://host:port or https://host:port)",
+                },
+                noDelay: {
+                    type: "boolean",
+                    description: "Optional flag to disable random delay between requests (default: false)",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Optional timeout in milliseconds (default: 30000)",
+                },
+                maxRedirects: {
+                    type: "number",
+                    description: "Optional maximum number of redirects to follow (default: 10)",
+                },
+                useSystemProxy: {
+                    type: "boolean",
+                    description: "Optional flag to use system proxy environment variables (default: true)",
+                },
+                debug: {
+                    type: "boolean",
+                    description: "Optional flag to enable detailed debug logging (default: false)",
+                },
+                useBrowser: {
+                    type: "boolean",
+                    description: "Optional flag to use headless browser for fetching (default: false)",
+                },
+                autoDetectMode: {
+                    type: "boolean",
+                    description: "Optional flag to automatically switch to browser mode if standard fetch fails (default: true). Set to false to strictly use the specified mode without automatic switching.",
+                },
+                waitForSelector: {
+                    type: "string",
+                    description: "Optional CSS selector to wait for when using browser mode",
+                },
+                waitForTimeout: {
+                    type: "number",
+                    description: "Optional timeout to wait after page load in browser mode (default: 5000)",
+                },
+                scrollToBottom: {
+                    type: "boolean",
+                    description: "Optional flag to scroll to bottom of page in browser mode (default: false)",
+                },
+                saveCookies: {
+                    type: "boolean",
+                    description: "Optional flag to save cookies for future requests to the same domain (default: true)",
+                },
+                closeBrowser: {
+                    type: "boolean",
+                    description: "Optional flag to close the browser after fetching (default: false)",
+                },
+                contentSizeLimit: {
+                    type: "number",
+                    description: "Optional maximum content size in bytes before splitting into chunks (default: 50KB). Set between 20KB-50KB for optimal results. For large content, prefer smaller values (20KB-30KB) to avoid truncation.",
+                },
+                enableContentSplitting: {
+                    type: "boolean",
+                    description: "Optional flag to enable content splitting for large responses (default: true)",
+                },
+                chunkId: {
+                    type: "string",
+                    description: `Optional chunk ID for retrieving a specific chunk of content from a previous request. The system adds prompts in the format ${TemplateUtils.SYSTEM_NOTE.START} ... ${TemplateUtils.SYSTEM_NOTE.END} which AI models should ignore when processing the content.`,
+                },
             },
-            required: ["url"],
+            required: ["url", "startCursor"],
         },
     };
 }
@@ -284,7 +442,8 @@ function getAllToolDefinitions() {
         getHtmlFetchToolDefinition(),
         getJsonFetchToolDefinition(),
         getTextFetchToolDefinition(),
-        getMarkdownFetchToolDefinition()
+        getMarkdownFetchToolDefinition(),
+        getPlainTextFetchToolDefinition()
     ];
 }
 /**
@@ -310,7 +469,7 @@ function registerToolCallHandler(server) {
         log('tools.callReceived', debug, { name, args: JSON.stringify(args) }, COMPONENTS.SERVER);
         try {
             // 处理不同类型的获取请求 (Handle different types of fetch requests)
-            if (name === 'fetch_html' || name === 'fetch_json' || name === 'fetch_txt' || name === 'fetch_markdown') {
+            if (name === 'fetch_html' || name === 'fetch_json' || name === 'fetch_txt' || name === 'fetch_markdown' || name === 'fetch_plaintext') {
                 const result = await handleFetchRequest(name, args, debug);
                 // 直接返回符合 MCP SDK 要求的格式
                 return result;
@@ -318,29 +477,13 @@ function registerToolCallHandler(server) {
             else {
                 // 未知工具 (Unknown tool)
                 log('tools.unknownTool', debug, { name }, COMPONENTS.SERVER);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Unknown tool: ${name}`
-                        }
-                    ],
-                    isError: true
-                };
+                return BaseFetcher.createErrorResponse(`Unknown tool: ${name}`);
             }
         }
         catch (error) {
             // 处理错误 (Handle error)
             log('tools.callError', debug, { name, error: error.message }, COMPONENTS.SERVER);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: error.message
-                    }
-                ],
-                isError: true
-            };
+            return BaseFetcher.createErrorResponse(`Error fetching ${args.url || `chunk ${args.chunkId}`}: ${error.message}`);
         }
         finally {
             // 如果请求参数中指定了关闭浏览器，则关闭浏览器 (If request parameters specify to close browser, close browser)
@@ -359,20 +502,22 @@ function registerToolCallHandler(server) {
  */
 async function handleFetchRequest(name, args, debug) {
     // 验证URL参数 (Validate URL parameter)
-    if (!args.url) {
-        log('tools.missingUrl', debug, {}, COMPONENTS.SERVER);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "URL parameter is required"
-                }
-            ],
-            isError: true
-        };
+    if (!args.url && !args.chunkId) {
+        log('tools.missingUrlOrChunkId', debug, {}, COMPONENTS.SERVER);
+        return BaseFetcher.createErrorResponse("Either URL or chunkId parameter is required");
+    }
+    // 验证startCursor参数 (Validate startCursor parameter)
+    if (args.startCursor === undefined) {
+        log('tools.missingStartCursor', debug, {}, COMPONENTS.SERVER);
+        return BaseFetcher.createErrorResponse("startCursor parameter is required. Use 0 for initial requests.");
     }
     // 记录请求 (Log request)
-    log('tools.fetchRequest', debug, { url: args.url, type: name }, COMPONENTS.SERVER);
+    if (args.chunkId) {
+        log('tools.fetchChunkRequest', debug, { chunkId: args.chunkId, startCursor: args.startCursor, type: name }, COMPONENTS.SERVER);
+    }
+    else {
+        log('tools.fetchRequest', debug, { url: args.url, startCursor: args.startCursor, type: name }, COMPONENTS.SERVER);
+    }
     // 执行获取请求 (Execute fetch request)
     try {
         const params = {
@@ -381,7 +526,7 @@ async function handleFetchRequest(name, args, debug) {
         };
         // 根据工具名称确定内容类型 (Determine content type based on tool name)
         const type = name.replace('fetch_', '');
-        const result = await fetchWithAutoDetect(params, type);
+        let result = await fetchWithAutoDetect(params, type);
         // 确保返回标准结构体 (Ensure returning standard structure)
         if (result.isError) {
             // 确保错误内容有正确的类型 (Ensure error content has correct type)
@@ -407,6 +552,19 @@ async function handleFetchRequest(name, args, debug) {
             if (!result.content[0].type) {
                 result.content[0].type = "text";
             }
+            // 如果内容是分段的，添加提示词 (If content is chunked, add prompt)
+            if (result.isChunked && result.hasMoreChunks) {
+                // 检查内容中是否已经包含系统提示，避免重复添加
+                // Check if content already contains system note to avoid duplicate
+                if (!TemplateUtils.hasSystemPrompt(result.content[0].text || '')) {
+                    // 使用BaseFetcher的addChunkPrompt方法添加提示词 (Use BaseFetcher's addChunkPrompt method to add prompt)
+                    result = BaseFetcher.addChunkPrompt(result);
+                }
+            }
+        }
+        // 如果没有匹配的类型，返回错误
+        if (!result.content[0].type) {
+            return BaseFetcher.createErrorResponse(`Unsupported content type: ${type}`);
         }
         // 将FetchResponse转换为符合MCP SDK要求的格式
         return {
@@ -417,16 +575,8 @@ async function handleFetchRequest(name, args, debug) {
     catch (error) {
         // 处理错误 (Handle error)
         log('tools.fetchError', debug, { url: args.url, error: error.message }, COMPONENTS.SERVER);
-        // 确保返回标准结构体 (Ensure returning standard structure)
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error fetching ${args.url}: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+        // 返回错误信息 (Return error message)
+        return BaseFetcher.createErrorResponse(`Error fetching ${args.url || `chunk ${args.chunkId}`}: ${error.message}`);
     }
 }
 /**

package/dist/src/lib/types.js

@@ -32,4 +32,9 @@ export const RequestPayloadSchema = z.object({
     waitForTimeout: z.number().optional(),
     scrollToBottom: z.boolean().optional(),
     closeBrowser: z.boolean().optional(),
+    chunkId: z.string().optional(),
+    chunkIndex: z.number().optional(),
+    contentSizeLimit: z.number().optional(),
+    startCursor: z.number().optional(),
+    enableContentSplitting: z.boolean().optional(),
 }).merge(BrowserParamsSchema);