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

package/README.md

@@ -33,20 +33,21 @@ This project implements an MCP-compliant client and server for communication bet
 fetch-mcp/
 ├── src/                         # Source code directory
 │   ├── lib/                     # Library files
-│   │   ├── fetchers/            # Web fetching implementations
+│   │   ├── fetchers/            # Web fetching implementation
 │   │   │   ├── browser/         # Browser-based fetching
-│   │   │   │   ├── BrowserFetcher.ts      # Browser fetching implementation
+│   │   │   │   ├── BrowserFetcher.ts      # Browser fetcher implementation
 │   │   │   │   ├── BrowserInstance.ts     # Browser instance management
 │   │   │   │   └── PageOperations.ts      # Page interaction operations
 │   │   │   ├── node/            # Node.js-based fetching
 │   │   │   └── common/          # Shared fetching utilities
 │   │   ├── utils/               # Utility modules
-│   │   │   ├── ChunkManager.ts        # Content chunking functionality
+│   │   │   ├── ChunkManager.ts        # Content chunking
 │   │   │   ├── ContentProcessor.ts    # HTML to text conversion
+│   │   │   ├── ContentExtractor.ts    # Intelligent content extraction
 │   │   │   ├── ContentSizeManager.ts  # Content size limiting
-│   │   │   └── ErrorHandler.ts        # Error management
+│   │   │   └── ErrorHandler.ts        # Error handling
 │   │   ├── server/              # Server-related modules
-│   │   │   ├── index.ts         # Server entry point
+│   │   │   ├── index.ts         # Server entry
 │   │   │   ├── browser.ts       # Browser management
 │   │   │   ├── fetcher.ts       # Web fetching logic
 │   │   │   ├── tools.ts         # Tool registration and handling
@@ -76,12 +77,16 @@ This project implements the Standard Input/Output (Stdio) transport method.
 - Implementation based on the official MCP SDK
 - Support for Standard Input/Output (Stdio) transport
 - Multiple web scraping methods (HTML, JSON, text, Markdown, plain text conversion)
-- Intelligent mode switching: automatically switches between standard requests and browser mode
-- Content size management: automatically splits large content into manageable chunks to overcome AI context size limitations
+- Intelligent mode switching: automatic switching between standard requests and browser mode
+- Content size management: automatically splits large content into manageable chunks to solve AI model context size limitations
 - Chunked content retrieval: ability to request specific chunks of large content while maintaining context continuity
-- Detailed debug logs output to standard error stream
-- Support for Chinese and English bilingual internationalization
+- Detailed debug logging to stderr
+- Bilingual internationalization (English and Chinese)
 - Modular design for easy maintenance and extension
+- **Intelligent Content Extraction**: Based on Mozilla's Readability library, capable of extracting meaningful content from web pages while filtering out advertisements and navigation elements
+- **Metadata Support**: Ability to extract webpage metadata such as title, author, publication date, and site information
+- **Smart Content Detection**: Automatically detects if a page contains meaningful content, filtering out login pages, error pages, and other pages without substantial content
+- **Browser Automation Enhancements**: Support for page scrolling, cookie management, selector waiting, and other advanced browser interactions
 
 ## Installation
 
@@ -493,8 +498,8 @@ Each tool supports the following parameters:
 
 #### Basic Parameters
 - `url`: URL to fetch (required)
-- `headers`: Custom request headers (optional, default is {})
-- `proxy`: Proxy server URL in format http://host:port or https://host:port (optional)
+- `headers`: Custom request headers (optional, default {})
+- `proxy`: Proxy server URL in the format http://host:port or https://host:port (optional)
 
 #### Network Control Parameters
 - `timeout`: Timeout in milliseconds (optional, default is 30000)
@@ -526,11 +531,58 @@ When content is split into chunks, the response includes metadata that allows th
 - `saveCookies`: Whether to save cookies in browser mode (optional, default is true)
 - `closeBrowser`: Whether to close the browser instance (optional, default is false)
 
+#### Content Extraction Parameters
+- `extractContent`: Whether to use the Readability algorithm to extract main content (optional, default false)
+- `includeMetadata`: Whether to include metadata in the extracted content (optional, default false, only works when `extractContent` is true)
+- `fallbackToOriginal`: Whether to fall back to the original content when extraction fails (optional, default true, only works when `extractContent` is true)
+
 #### Debug Parameters
-- `debug`: Whether to enable debug output (optional, default is false)
+- `debug`: Whether to enable debug output (optional, default false)
+
+### Content Extraction Feature
+
+Use the content extraction feature to get the core content of a webpage, filtering out navigation bars, advertisements, sidebars, and other distracting elements:
+
+```json
+{
+  "url": "https://example.com/article",
+  "extractContent": true,
+  "includeMetadata": true
+}
+```
+
+The extracted content will include the following metadata (if available):
+- Title
+- Byline (author)
+- Site name
+- Excerpt
+- Content length
+- Readability flag (isReaderable)
 
 ### Special Usage
 
+#### Content Extraction Examples
+
+To extract only the meaningful content from an article webpage:
+
+```json
+{
+  "url": "https://example.com/news/article",
+  "extractContent": true,
+  "includeMetadata": true
+}
+```
+
+For websites where content extraction might fail, you can use `fallbackToOriginal` to ensure you get some content:
+
+```json
+{
+  "url": "https://example.com/complex-layout",
+  "extractContent": true,
+  "fallbackToOriginal": true
+}
+```
+
 #### Closing Browser Without Fetching
 To close the browser instance without performing any fetch operation:
 ```json
@@ -551,19 +603,20 @@ If `proxy` is set, `useSystemProxy` will be automatically set to false.
 
 ### Debug Output
 
-When `debug: true` is set, the logs will be output to stderr with the following prefixes:
+When `debug: true` is set, logs will be output to stderr with the following prefixes:
 - `[MCP-SERVER]`: Logs from the MCP server
 - `[NODE-FETCH]`: Logs from the Node.js fetcher
 - `[BROWSER-FETCH]`: Logs from the browser fetcher
 - `[CLIENT]`: Logs from the client
-- `[TOOLS]`: Logs from the tools implementation
+- `[TOOLS]`: Logs from the tool implementation
 - `[FETCHER]`: Logs from the main fetcher interface
-- `[CONTENT]`: Logs related to content processing
+- `[CONTENT]`: Logs related to content handling
 - `[CONTENT-PROCESSOR]`: Logs from the HTML content processor
 - `[CONTENT-SIZE]`: Logs related to content size management
 - `[CHUNK-MANAGER]`: Logs related to content chunking operations
 - `[ERROR-HANDLER]`: Logs related to error handling
 - `[BROWSER-MANAGER]`: Logs from the browser instance manager
+- `[CONTENT-EXTRACTOR]`: Logs from the content extractor
 
 
 ## License

package/README.zh.md

@@ -40,6 +40,7 @@ fetch-mcp/
 │   │   ├── utils/               # 工具模块
 │   │   │   ├── ChunkManager.ts        # 内容分块功能
 │   │   │   ├── ContentProcessor.ts    # HTML到文本转换
+│   │   │   ├── ContentExtractor.ts    # 内容智能提取
 │   │   │   ├── ContentSizeManager.ts  # 内容大小限制
 │   │   │   └── ErrorHandler.ts        # 错误处理
 │   │   ├── server/              # 服务器相关模块
@@ -79,6 +80,10 @@ fetch-mcp/
 - 详细的调试日志输出到标准错误流
 - 支持中英文双语国际化
 - 模块化设计，便于维护和扩展
+- **智能内容提取**：基于Mozilla Readability库，能够从网页中提取有意义的主要内容，过滤广告和导航元素
+- **元数据支持**：能够提取网页元数据，如标题、作者、发布日期、站点信息等
+- **智能内容分析**：自动检测页面是否包含有意义的内容，过滤登录页、错误页等无实质内容的页面
+- **浏览器自动化增强**：支持页面滚动、Cookie管理、选择器等待等高级浏览器交互
 
 ## 安装
 
@@ -525,9 +530,34 @@ console.log('调试获取提示:', debugPrompt);
 - `saveCookies`: 浏览器模式下是否保存cookies（可选，默认为true）
 - `closeBrowser`: 是否关闭浏览器实例（可选，默认为false）
 
+#### 内容提取参数
+- `extractContent`: 是否使用Readability算法提取主要内容（可选，默认为false）
+- `includeMetadata`: 是否在提取的内容中包含元数据（可选，默认为false，仅当`extractContent`为true时有效）
+- `fallbackToOriginal`: 当提取失败时是否回退到原始内容（可选，默认为true，仅当`extractContent`为true时有效）
+
 #### 调试参数
 - `debug`: 是否启用调试输出（可选，默认为false）
 
+### 内容提取特性
+
+使用内容提取功能可以获取网页的核心内容，过滤掉导航栏、广告、侧边栏等干扰元素：
+
+```json
+{
+  "url": "https://example.com/article",
+  "extractContent": true,
+  "includeMetadata": true
+}
+```
+
+提取的内容将包括以下元数据（如果可用）：
+- 标题 (title)
+- 作者 (byline)
+- 站点名称 (siteName)
+- 摘要 (excerpt)
+- 内容长度 (length)
+- 可读性标志 (isReaderable)
+
 ### 特殊用法
 
 #### 不获取内容直接关闭浏览器
@@ -563,6 +593,7 @@ console.log('调试获取提示:', debugPrompt);
 - `[CHUNK-MANAGER]`: 内容分块操作相关的日志
 - `[ERROR-HANDLER]`: 错误处理相关的日志
 - `[BROWSER-MANAGER]`: 浏览器实例管理器的日志
+- `[CONTENT-EXTRACTOR]`: 内容提取器的日志
 
 
 ## 许可证

package/dist/src/client.js

@@ -81,7 +81,7 @@ function responseRequiresBrowser(response, debug = false) {
  * @param params 请求参数 (Request parameters)
  * @param debug 是否为调试模式 (Whether in debug mode)
  */
-function saveChunkInfo(result, params, debug = false) {
+function _saveChunkInfo(result, params, debug = false) {
     if (result.isChunked && result.hasMoreChunks) {
         try {
             const chunkInfo = {
@@ -101,9 +101,9 @@ function saveChunkInfo(result, params, debug = false) {
                 }, COMPONENTS.CLIENT);
             }
         }
-        catch (error) {
+        catch (_error) {
             if (debug) {
-                log('client.chunkInfoSaveError', debug, { error: String(error) }, COMPONENTS.CLIENT);
+                log('client.chunkInfoSaveError', debug, { error: String(_error) }, COMPONENTS.CLIENT);
             }
         }
     }
@@ -113,7 +113,7 @@ function saveChunkInfo(result, params, debug = false) {
  * @param debug 是否为调试模式 (Whether in debug mode)
  * @returns 分段信息 (Chunk information)
  */
-function loadChunkInfo(debug = false) {
+function _loadChunkInfo(debug = false) {
     try {
         if (fs.existsSync(CHUNK_INFO_FILE)) {
             const chunkInfoStr = fs.readFileSync(CHUNK_INFO_FILE, 'utf8');
@@ -128,9 +128,9 @@ function loadChunkInfo(debug = false) {
             return chunkInfo;
         }
     }
-    catch (error) {
+    catch (_error) {
         if (debug) {
-            log('client.chunkInfoLoadError', debug, { error: String(error) }, COMPONENTS.CLIENT);
+            log('client.chunkInfoLoadError', debug, { error: String(_error) }, COMPONENTS.CLIENT);
         }
     }
     return null;
@@ -140,17 +140,19 @@ function loadChunkInfo(debug = false) {
  * @param result 响应结果 (Response result)
  * @returns 包含分段信息的结果 (Result with chunk information)
  */
-function parseChunkInfo(result) {
+function _parseChunkInfo(result) {
     if (result.isError || !result.content || !result.content[0] || !result.content[0].text) {
         return result;
     }
     const content = result.content[0].text;
-    const chunkIdMatch = content.match(/chunkId="([^"]+)"/);
-    // 更新正则表达式，识别新的基于字节的分块信息 (Update regex to identify new byte-based chunking info)
-    const byteInfoMatch = content.match(/(\d+) bytes retrieved \((\d+)% of total (\d+) bytes\)/);
-    const remainingBytesMatch = content.match(/(\d+) bytes remaining/);
-    // 存在chunkId但找不到分块信息，可能是老的格式 (ChunkId exists but no chunking info, might be old format)
-    const partMatch = content.match(/This is part (\d+) of (\d+)/);
+    // 首先检查API直接返回的isLastChunk标识
+    const isLastChunk = result.isLastChunk === true;
+    // 支持多种分块ID匹配模式 (Support multiple chunking ID matching patterns)
+    const systemNoteMatch = content.match(/=== SYSTEM NOTE ===\s*([\s\S]*?)\s*={19}/);
+    const chunkIdMatch = systemNoteMatch ?
+        systemNoteMatch[1].match(/chunkId(?:=|\s*[:=]\s*|\s*)?["']?([^"',\s]+)["']?/i) :
+        content.match(/chunkId="([^"]+)"/);
+    // 如果没有找到分块ID，返回原始结果 (If no chunk ID found, return original result)
     if (!chunkIdMatch) {
         return result;
     }
@@ -161,19 +163,37 @@ function parseChunkInfo(result) {
     let fetchedBytes = 0;
     let totalBytes = 0;
     let remainingBytes = 0;
+    // 查找字节级分块信息 (Look for byte-level chunking information)
+    const byteInfoMatch = systemNoteMatch ?
+        systemNoteMatch[1].match(/(\d+(?:,\d+)*)\s*bytes\s*(?:retrieved|fetched).*?(\d+)%\s*of\s*(?:the\s*)?total\s*(\d+(?:,\d+)*)\s*bytes/) :
+        content.match(/retrieved ([,\d]+) bytes \((\d+)% of total ([,\d]+) bytes\)/);
+    const remainingBytesMatch = systemNoteMatch ?
+        systemNoteMatch[1].match(/(\d+(?:,\d+)*)\s*bytes\s*(?:are\s*)?remaining/) :
+        content.match(/([,\d]+) bytes remaining/);
+    // 查找旧版分块信息 (Look for old version chunking information)
+    const partMatch = systemNoteMatch ?
+        systemNoteMatch[1].match(/This is part (\d+) of (\d+)/) :
+        content.match(/This is part (\d+) of (\d+)/);
+    // 检查是否有"最后一部分"的提示 (Check if there's a "last part" hint)
+    const lastPartMatch = systemNoteMatch ?
+        systemNoteMatch[1].match(/(?:this|the) (?:is|last|final) (?:the|last|final)? part/i) :
+        content.match(/(?:this|the) (?:is|last|final) (?:the|last|final)? part/i);
+    // 如果有直接指示这是最后一部分的消息，设置isLastChunk为true (If there's a message directly indicating this is the last part, set isLastChunk to true)
+    const contentIndicatesLastChunk = !!lastPartMatch || content.includes("No further requests needed");
     // 检查是否包含字节级分块信息 (Check if contains byte-level chunking info)
     if (byteInfoMatch) {
-        fetchedBytes = parseInt(byteInfoMatch[1], 10);
-        const percentage = parseInt(byteInfoMatch[2], 10);
-        totalBytes = parseInt(byteInfoMatch[3], 10);
+        // 移除千位分隔符逗号 (Remove thousands separator commas)
+        fetchedBytes = parseInt(byteInfoMatch[1].replace(/,/g, ''), 10);
+        const _percentage = parseInt(byteInfoMatch[2], 10);
+        totalBytes = parseInt(byteInfoMatch[3].replace(/,/g, ''), 10);
         if (remainingBytesMatch) {
-            remainingBytes = parseInt(remainingBytesMatch[1], 10);
+            remainingBytes = parseInt(remainingBytesMatch[1].replace(/,/g, ''), 10);
         }
         else {
             remainingBytes = totalBytes - fetchedBytes;
         }
-        // 如果还有剩余字节，表示有更多分块 (If there are remaining bytes, indicates more chunks)
-        hasMoreChunks = remainingBytes > 0;
+        // 如果有明确的isLastChunk标识或内容中有指示，或者剩余字节为0，表示没有更多分块
+        hasMoreChunks = !(isLastChunk || contentIndicatesLastChunk || remainingBytes <= 0);
         // 估算总分块数 (Estimate total chunks)
         if (fetchedBytes > 0) {
             // 估算总块数，基于已获取的字节数 (Estimate total chunks based on fetched bytes)
@@ -186,7 +206,8 @@ function parseChunkInfo(result) {
     else if (partMatch) {
         currentChunk = parseInt(partMatch[1], 10) - 1; // 转换为0索引 (Convert to 0-based index)
         totalChunks = parseInt(partMatch[2], 10);
-        hasMoreChunks = currentChunk < totalChunks - 1;
+        // 如果有明确的isLastChunk标识或内容中有指示，或者当前是最后一块，表示没有更多分块
+        hasMoreChunks = !(isLastChunk || contentIndicatesLastChunk || currentChunk >= totalChunks - 1);
     }
     return {
         ...result,
@@ -197,7 +218,9 @@ function parseChunkInfo(result) {
         totalChunks,
         fetchedBytes,
         totalBytes,
-        remainingBytes
+        remainingBytes,
+        // 合并所有最后分块的判断条件
+        isLastChunk: isLastChunk || contentIndicatesLastChunk || remainingBytes <= 0 || (partMatch && currentChunk >= totalChunks - 1)
     };
 }
 /**
@@ -265,7 +288,17 @@ async function smartFetch(params, client) {
 async function main() {
     // 检查是否请求所有分段内容 (Check if requesting all chunks)
     const allChunksFlag = process.argv.includes('--all-chunks');
-    let method;
+    // 获取方法 (Get method)
+    if (process.argv.length < 3) {
+        log('client.usageInfo', true, { info: 'node src/client.js <method> <params_json> [--debug] [--all-chunks] [--max-chunks=N]' }, COMPONENTS.CLIENT);
+        log('client.exampleUsage', true, { example: 'node src/client.js fetch_html {"url":"https://example.com"}' }, COMPONENTS.CLIENT);
+        log('client.chunkUsageInfo', true, {}, COMPONENTS.CLIENT);
+        log('client.allChunksUsageInfo', true, {}, COMPONENTS.CLIENT);
+        log('client.maxChunksUsageInfo', true, { default: DEFAULT_MAX_CHUNKS }, COMPONENTS.CLIENT);
+        log('client.alternateUsageInfo', true, { example: 'node src/client.js fetch_html --url=https://example.com --startCursor=0' }, COMPONENTS.CLIENT);
+        process.exit(1);
+    }
+    const method = process.argv[2];
     let params = {};
     let paramsJson = "{}";
     // 获取最大分块数限制 (Get maximum chunk limit)
@@ -278,17 +311,6 @@ async function main() {
         }
     }
     // 解析命令行参数 (Parse command line arguments)
-    if (process.argv.length < 3) {
-        log('client.usageInfo', true, { info: 'node src/client.js <method> <params_json> [--debug] [--all-chunks] [--max-chunks=N]' }, COMPONENTS.CLIENT);
-        log('client.exampleUsage', true, { example: 'node src/client.js fetch_html {"url":"https://example.com"}' }, COMPONENTS.CLIENT);
-        log('client.chunkUsageInfo', true, {}, COMPONENTS.CLIENT);
-        log('client.allChunksUsageInfo', true, {}, COMPONENTS.CLIENT);
-        log('client.maxChunksUsageInfo', true, { default: DEFAULT_MAX_CHUNKS }, COMPONENTS.CLIENT);
-        log('client.alternateUsageInfo', true, { example: 'node src/client.js fetch_html --url=https://example.com --startCursor=0' }, COMPONENTS.CLIENT);
-        process.exit(1);
-    }
-    method = process.argv[2];
-    // 检查参数格式：JSON 或 命令行参数 (Check parameter format: JSON or command line arguments)
     const thirdArg = process.argv[3];
     const isJsonParams = thirdArg && thirdArg.startsWith('{') && thirdArg.endsWith('}');
     if (isJsonParams) {
@@ -297,8 +319,8 @@ async function main() {
         try {
             params = JSON.parse(paramsJson);
         }
-        catch (e) {
-            log('client.invalidJson', true, { error: String(e) }, COMPONENTS.CLIENT);
+        catch (_error) {
+            log('client.invalidJson', true, { error: String(_error) }, COMPONENTS.CLIENT);
             process.exit(1);
         }
     }
@@ -366,7 +388,7 @@ async function main() {
                             proxyUrl = proxyMatch[1].trim();
                         }
                     }
-                    catch (error) {
+                    catch (_error) {
                         // 忽略错误 (Ignore errors)
                     }
                 }
@@ -379,7 +401,7 @@ async function main() {
                             proxyUrl = proxyMatch[1].trim();
                         }
                     }
-                    catch (error) {
+                    catch (_error) {
                         // 忽略错误 (Ignore errors)
                     }
                 }
@@ -391,7 +413,7 @@ async function main() {
                     log('client.noSystemProxy', debug, {}, COMPONENTS.CLIENT);
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // 忽略错误 (Ignore errors)
             }
         }
@@ -431,33 +453,28 @@ async function main() {
             method
         };
         // 获取第一段内容 (Fetch first chunk)
-        let result = await smartFetch(initialParams, client);
+        const result = await smartFetch(initialParams, client);
         // 调试输出，查看响应结构 (Debug output, check response structure)
         if (debug) {
             log('client.responseStructure', debug, { structure: JSON.stringify(result, null, 2) }, COMPONENTS.CLIENT);
         }
         // 从响应内容中解析分段信息 (Parse chunk information from response content)
-        let chunkId;
-        let currentChunk = 0;
-        let totalChunks = 1;
         let hasMoreChunks = false;
+        let chunkId = '';
+        let totalChunks = 1;
+        let currentChunk = 0;
+        // 检查是否有明确的最后分块标识
+        const isLastChunk = result.isLastChunk === true;
+        // 解析响应内容中的分段信息 (Parse chunk information from response content)
         if (result.content && result.content[0] && result.content[0].text) {
             const content = result.content[0].text;
-            // Update regex to match chunk information in system notes
-            const systemNoteMatch = content.match(/=== SYSTEM NOTE ===\s*([\s\S]*?)\s*={19}/);
-            const chunkIdMatch = systemNoteMatch ? systemNoteMatch[1].match(/chunkId(?:=|\s*[:=]\s*|\s*)?["']?([^"',\s]+)["']?/i) : null;
-            // 匹配字节级分块信息 (Match byte-level chunking information)
-            // 更新正则表达式来适应新的系统注释格式 (Update regex to adapt to new system note format)
-            const bytesRetrievedMatch = systemNoteMatch ?
-                systemNoteMatch[1].match(/(?:You'?(?:ve|have))?\s*retrieved\s*(\d+(?:,\d+)*)\s*bytes\s*\((\d+)%\s*of\s*(?:the\s*)?total\s*(\d+(?:,\d+)*)\s*bytes\)/) : null;
-            // 尝试兼容新旧两种格式 (Try to be compatible with both new and old formats)
-            const remainingBytesMatch = systemNoteMatch ?
-                systemNoteMatch[1].match(/(\d+(?:,\d+)*)\s*bytes\s*(?:are\s*)?remaining/) : null;
-            const moreRequestsMatch = systemNoteMatch ?
-                systemNoteMatch[1].match(/(?:a|ap)proximately\s*(\d+)\s*more\s*requests?\s*(?:are\s*)?needed/) : null;
-            // 旧版分块信息匹配 (Old version chunking information matching)
-            const partMatch = systemNoteMatch ?
-                systemNoteMatch[1].match(/This is part (\d+) of (\d+)/) : null;
+            const chunkIdMatch = content.match(/chunkId="([^"]+)"/);
+            const startCursorMatch = content.match(/startCursor=(\d+)/);
+            const bytesRetrievedMatch = content.match(/retrieved ([,\d]+) bytes \((\d+)% of total ([,\d]+) bytes\)/);
+            const remainingBytesMatch = content.match(/([,\d]+) bytes remaining/);
+            const moreRequestsMatch = content.match(/approximately (\d+) more requests needed/);
+            const partMatch = content.match(/This is part (\d+) of (\d+)/);
+            // 如果找到了分块ID匹配 (If chunk ID match found)
             if (chunkIdMatch) {
                 chunkId = chunkIdMatch[1];
                 // 判断是否有字节级分块信息 (Check if there's byte-level chunking info)
@@ -466,7 +483,7 @@ async function main() {
                     const fetchedBytesStr = bytesRetrievedMatch[1].replace(/,/g, '');
                     const totalBytesStr = bytesRetrievedMatch[3].replace(/,/g, '');
                     const fetchedBytes = parseInt(fetchedBytesStr, 10);
-                    const percentage = parseInt(bytesRetrievedMatch[2], 10);
+                    const _percentage = parseInt(bytesRetrievedMatch[2], 10);
                     const totalBytes = parseInt(totalBytesStr, 10);
                     let remainingBytes = 0;
                     if (remainingBytesMatch) {
@@ -475,8 +492,8 @@ async function main() {
                     else {
                         remainingBytes = totalBytes - fetchedBytes;
                     }
-                    // 如果还有剩余字节，表示有更多分块 (If there are remaining bytes, indicates more chunks)
-                    hasMoreChunks = remainingBytes > 0;
+                    // 如果使用isLastChunk标识，优先使用它；否则基于remainingBytes计算
+                    hasMoreChunks = isLastChunk ? false : remainingBytes > 0;
                     // 估算剩余的请求次数 (Estimate remaining requests)
                     let estimatedRemainingRequests = 0;
                     if (moreRequestsMatch) {
@@ -493,38 +510,48 @@ async function main() {
                     result.fetchedBytes = fetchedBytes;
                     result.totalBytes = totalBytes;
                     result.remainingBytes = remainingBytes;
-                    // 调试输出，查看解析后的分段信息 (Debug output, check parsed chunk information)
-                    if (debug) {
-                        log('client.parsedByteChunkInfo', debug, {
-                            chunkId,
-                            fetchedBytes,
-                            totalBytes,
-                            remainingBytes,
-                            estimatedRemainingRequests
-                        }, COMPONENTS.CLIENT);
-                    }
+                    // 如果服务器返回了isLastChunk属性，使用它；否则基于remainingBytes计算
+                    result.isLastChunk = isLastChunk || remainingBytes <= 0;
+                    result.hasMoreChunks = hasMoreChunks;
                 }
-                // 尝试匹配旧版的分块格式 (Try to match old version chunking format)
+                // 如果没有字节级信息，则使用分块匹配 (If no byte-level info, use chunk matching)
                 else if (partMatch) {
-                    currentChunk = parseInt(partMatch[1], 10) - 1; // 转换为0索引 (Convert to 0-based index)
+                    currentChunk = parseInt(partMatch[1], 10) - 1;
                     totalChunks = parseInt(partMatch[2], 10);
-                    hasMoreChunks = currentChunk < totalChunks - 1;
-                    // 调试输出，查看解析后的分段信息 (Debug output, check parsed chunk information)
-                    if (debug) {
-                        log('client.parsedChunkInfo', debug, {
-                            chunkId,
-                            currentChunk,
-                            totalChunks,
-                            hasMoreChunks
-                        }, COMPONENTS.CLIENT);
-                    }
+                    hasMoreChunks = isLastChunk ? false : currentChunk < totalChunks - 1;
+                }
+                // 如果有启动游标信息，这表明还有更多分块 (If start cursor info exists, indicates more chunks)
+                else if (startCursorMatch) {
+                    hasMoreChunks = !isLastChunk && true;
                 }
+                // 使用解析出的分段信息 (Use parsed chunk information)
+                result.isChunked = hasMoreChunks;
+                result.hasMoreChunks = hasMoreChunks;
+                result.chunkId = chunkId;
+                result.currentChunk = currentChunk;
+                result.totalChunks = totalChunks;
+                // 保存分段信息到临时文件 (Save chunk information to temporary file)
+                _saveChunkInfo(result, params, debug);
             }
         }
-        // 输出第一段内容 (Output first chunk)
+        // 调试输出，查看解析后的分段信息 (Debug output, check parsed chunk information)
+        if (debug) {
+            log('client.chunkInfoParsed', debug, {
+                isChunked: result.isChunked,
+                hasMoreChunks,
+                isLastChunk,
+                chunkId,
+                currentChunk,
+                totalChunks,
+                fetchedBytes: result.fetchedBytes,
+                totalBytes: result.totalBytes,
+                remainingBytes: result.remainingBytes
+            }, COMPONENTS.CLIENT);
+        }
+        // 输出结果 (Output result)
         console.log(JSON.stringify(result, null, 2));
         // 如果启用了获取所有分段内容，并且结果包含分段信息 (If all chunks mode is enabled and result contains chunk information)
-        if (allChunksFlag && hasMoreChunks && chunkId) {
+        if (allChunksFlag && hasMoreChunks && chunkId && !isLastChunk) {
             try {
                 // 确保totalChunks的计算正确 (Ensure totalChunks calculation is correct)
                 if (result.totalBytes && result.fetchedBytes) {
@@ -640,14 +667,14 @@ async function main() {
                     log('client.completeChunksFetched', true, { total: totalChunks }, COMPONENTS.CLIENT);
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // 处理获取分块内容过程中的错误 (Handle errors during chunk fetching)
-                log('client.fetchingChunksError', true, { error: String(error) }, COMPONENTS.CLIENT);
-                log('client.fetchingChunksErrorMessage', true, { error: String(error) }, COMPONENTS.CLIENT);
+                log('client.fetchingChunksError', true, { error: String(_error) }, COMPONENTS.CLIENT);
+                log('client.fetchingChunksErrorMessage', true, { error: String(_error) }, COMPONENTS.CLIENT);
             }
         }
         // 如果结果包含分段信息，但没有启用获取所有分段内容 (If result contains chunk information but all chunks mode is not enabled)
-        else if (hasMoreChunks && chunkId) {
+        else if (hasMoreChunks && chunkId && !isLastChunk) {
             log('client.hasMoreChunks', debug, {
                 current: currentChunk,
                 total: totalChunks,
@@ -672,16 +699,16 @@ async function main() {
             }
         }
     }
-    catch (error) {
+    catch (_error) {
         // 处理错误 (Handle error)
-        log('client.fatalError', true, { error: String(error) }, COMPONENTS.CLIENT);
+        log('client.fatalError', true, { error: String(_error) }, COMPONENTS.CLIENT);
         // 返回标准错误结构体 (Return standard error structure)
         const errorResult = {
             isError: true,
             content: [
                 {
                     type: "text",
-                    text: `Fatal error: ${String(error)}`
+                    text: `Fatal error: ${String(_error)}`
                 }
             ]
         };