@lmcc-dev/mult-fetch-mcp-server 1.2.1 → 1.3.1

package/dist/src/lib/fetch.js

@@ -28,6 +28,14 @@ export async function fetchJson(requestPayload) {
 export async function fetchTxt(requestPayload) {
     return await Fetcher.txt(requestPayload);
 }
+/**
+ * 获取HTML并转换为纯文本 (Get HTML and convert to plain text)
+ * @param requestPayload 请求参数 (Request parameters)
+ * @returns 纯文本内容 (Plain text content)
+ */
+export async function fetchPlainText(requestPayload) {
+    return await Fetcher.plainText(requestPayload);
+}
 /**
  * 获取Markdown内容 (Get Markdown content)
  * @param requestPayload 请求参数 (Request parameters)

package/dist/src/lib/fetchers/browser/BrowserFetcher.js

@@ -3,17 +3,19 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import TurndownService from 'turndown';
 import { JSDOM } from 'jsdom';
 import { log, COMPONENTS } from '../../logger.js';
 import { BrowserInstance } from './BrowserInstance.js';
 import { PageOperations, CookieManager } from './PageOperations.js';
 import { getRandomUserAgent, getSystemProxy } from '../common/utils.js';
+import { ContentSizeManager } from '../../utils/ContentSizeManager.js';
+import { BaseFetcher } from '../common/BaseFetcher.js';
+import { ContentProcessor } from '../../utils/ContentProcessor.js';
 /**
  * 浏览器模式获取器类 (Browser mode fetcher class)
  * 使用Puppeteer实现浏览器模式的网页获取 (Implements webpage fetching in browser mode using Puppeteer)
  */
-export class BrowserFetcher {
+export class BrowserFetcher extends BaseFetcher {
     /**
      * 使用Puppeteer获取网页内容 (Get webpage content using Puppeteer)
      * 浏览器模式获取的底层实现方法 (Low-level implementation method for browser mode fetching)
@@ -49,10 +51,7 @@ export class BrowserFetcher {
             // 如果只是要关闭浏览器，不需要获取内容
             if (url === 'about:blank' && closeBrowser) {
                 await BrowserInstance.closeBrowser(debug);
-                return {
-                    content: [{ type: 'text', text: 'Browser closed successfully' }],
-                    isError: false
-                };
+                return BaseFetcher.createSuccessResponse('Browser closed successfully');
             }
             // 获取浏览器实例
             const browser = await BrowserInstance.getBrowser(debug);
@@ -127,10 +126,7 @@ export class BrowserFetcher {
             if (closeBrowser) {
                 await BrowserInstance.closeBrowser(debug);
             }
-            return {
-                content: [{ type: 'text', text: finalContent }],
-                isError: false
-            };
+            return BaseFetcher.createSuccessResponse(finalContent);
         }
         catch (error) {
             log('browser.fetchError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
@@ -138,61 +134,43 @@ export class BrowserFetcher {
             if (closeBrowser) {
                 await BrowserInstance.closeBrowser(debug);
             }
-            return {
-                content: [{ type: 'text', text: `Error fetching ${url}: ${error}` }],
-                isError: true
-            };
+            return BaseFetcher.createErrorResponse(`Error fetching ${url}: ${error}`);
         }
     }
     /**
      * 使用Puppeteer获取HTML内容 (Get HTML content using Puppeteer)
-     * 通过浏览器模式获取网页HTML (Fetch webpage HTML in browser mode)
+     * 通过浏览器模式获取HTML页面 (Fetch HTML page in browser mode)
      * @param requestPayload 请求参数 (Request parameters)
      * @returns 获取结果 (Fetch result)
      */
     async html(requestPayload) {
-        const { url, debug = false, closeBrowser = false } = requestPayload;
-        // 如果只是要关闭浏览器，不需要获取内容
-        if (url === 'about:blank' && closeBrowser) {
-            log('browser.closingInstance', debug, { debug }, COMPONENTS.BROWSER_FETCH);
-            await BrowserInstance.closeBrowser(debug);
-            return {
-                content: [{ type: 'text', text: 'Browser closed successfully' }],
-                isError: false
-            };
+        const { url, debug = false, closeBrowser = false, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, chunkId, startCursor = 0 } = requestPayload;
+        // 如果提供了分段ID和起始游标，则从缓存中获取分段内容 (If chunk ID and startCursor are provided, get chunk content from cache)
+        if (chunkId && startCursor !== undefined) {
+            return this.getChunkContent(chunkId, startCursor, contentSizeLimit, debug, COMPONENTS.BROWSER_FETCH);
         }
-        // 设置最大重试次数
-        const maxRetries = 2;
-        const fetchWithRetry = async (retryCount = 0) => {
-            log('browser.fetchingWithRetry', debug, { attempt: retryCount + 1, maxAttempts: maxRetries, url }, COMPONENTS.BROWSER_FETCH);
-            try {
-                return await BrowserFetcher.fetch(requestPayload);
+        log('browser.startingHtmlFetch', debug, { url }, COMPONENTS.BROWSER_FETCH);
+        try {
+            // 使用通用的fetch方法获取内容 (Use common fetch method to get content)
+            const result = await BrowserFetcher.fetch(requestPayload);
+            // 如果出错，直接返回错误 (If error, return error directly)
+            if (result.isError) {
+                return result;
             }
-            catch (error) {
-                if (retryCount < maxRetries) {
-                    // 计算延迟时间，随着重试次数增加而增加
-                    const delayMs = 1000 * (retryCount + 1);
-                    log('browser.retryingAfterDelay', debug, { delayMs }, COMPONENTS.BROWSER_FETCH);
-                    // 等待一段时间后重试
-                    await new Promise(resolve => setTimeout(resolve, delayMs));
-                    return fetchWithRetry(retryCount + 1);
-                }
-                // 超过最大重试次数，返回错误
-                return {
-                    content: [{ type: 'text', text: `Error fetching ${url} after ${maxRetries + 1} attempts: ${error}` }],
-                    isError: true
-                };
+            // 获取HTML内容 (Get HTML content)
+            const html = result.content[0].text;
+            // 检查内容大小并处理 (Check content size and process)
+            const chunkingResult = this.handleContentChunking(html, contentSizeLimit, enableContentSplitting, debug, COMPONENTS.BROWSER_FETCH);
+            if (chunkingResult) {
+                return chunkingResult;
             }
-        };
-        try {
-            return await fetchWithRetry();
+            // 返回HTML内容 (Return HTML content)
+            return result;
         }
-        finally {
-            // 如果需要关闭浏览器
-            if (closeBrowser) {
-                log('browser.closingInstance', debug, {}, COMPONENTS.BROWSER_FETCH);
-                await BrowserInstance.closeBrowser(debug);
-            }
+        catch (error) {
+            // 处理错误 (Handle error)
+            log('browser.htmlFetchError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+            return BaseFetcher.createErrorResponse(`Error fetching HTML: ${error}`);
         }
     }
     /**
@@ -202,68 +180,43 @@ export class BrowserFetcher {
      * @returns 获取结果 (Fetch result)
      */
     async json(requestPayload) {
-        const { url, debug = false, closeBrowser = false } = requestPayload;
-        // 如果只是要关闭浏览器，不需要获取内容
-        if (url === 'about:blank' && closeBrowser) {
-            log('browser.closingInstance', debug, {}, COMPONENTS.BROWSER_FETCH);
-            await BrowserInstance.closeBrowser(debug);
-            return {
-                content: [{ type: 'text', text: 'Browser closed successfully' }],
-                isError: false
-            };
+        const { url, debug = false, closeBrowser = false, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, chunkId, startCursor = 0 } = requestPayload;
+        // 如果提供了分段ID和起始游标，则从缓存中获取分段内容 (If chunk ID and startCursor are provided, get chunk content from cache)
+        if (chunkId && startCursor !== undefined) {
+            return this.getChunkContent(chunkId, startCursor, contentSizeLimit, debug, COMPONENTS.BROWSER_FETCH);
         }
-        // 设置最大重试次数
-        const maxRetries = 2;
-        const fetchWithRetry = async (retryCount = 0) => {
-            log('browser.fetchingWithRetry', debug, { attempt: retryCount + 1, maxAttempts: maxRetries + 1, url }, COMPONENTS.BROWSER_FETCH);
+        log('browser.startingJsonFetch', debug, { url }, COMPONENTS.BROWSER_FETCH);
+        try {
+            // 使用通用的fetch方法获取内容 (Use common fetch method to get content)
+            const result = await BrowserFetcher.fetch(requestPayload);
+            // 如果出错，直接返回错误 (If error, return error directly)
+            if (result.isError) {
+                return result;
+            }
+            // 获取文本内容 (Get text content)
+            const text = result.content[0].text;
+            // 尝试解析JSON (Try to parse JSON)
             try {
-                const result = await BrowserFetcher.fetch(requestPayload);
-                // 如果获取成功，尝试解析JSON
-                if (!result.isError) {
-                    try {
-                        const jsonText = result.content[0].text;
-                        // 尝试解析JSON
-                        JSON.parse(jsonText);
-                        // 如果解析成功，直接返回结果
-                        return result;
-                    }
-                    catch (error) {
-                        // JSON解析失败
-                        log('browser.failedToParseJSON', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
-                        return {
-                            content: [{ type: 'text', text: `Error parsing JSON from ${url}: ${error}` }],
-                            isError: true
-                        };
-                    }
+                JSON.parse(text);
+                log('browser.jsonParsed', debug, {}, COMPONENTS.BROWSER_FETCH);
+                // 检查内容大小并处理 (Check content size and process)
+                const chunkingResult = this.handleContentChunking(text, contentSizeLimit, enableContentSplitting, debug, COMPONENTS.BROWSER_FETCH);
+                if (chunkingResult) {
+                    return chunkingResult;
                 }
+                // 返回JSON内容 (Return JSON content)
                 return result;
             }
-            catch (error) {
-                log('browser.fetchErrorWithAttempt', debug, { error: String(error), attempt: retryCount + 1, maxAttempts: maxRetries + 1 }, COMPONENTS.BROWSER_FETCH);
-                if (retryCount < maxRetries) {
-                    // 计算延迟时间，随着重试次数增加而增加
-                    const delayMs = 1000 * (retryCount + 1);
-                    log('browser.retryingAfterDelay', debug, { delayMs }, COMPONENTS.BROWSER_FETCH);
-                    // 等待一段时间后重试
-                    await new Promise(resolve => setTimeout(resolve, delayMs));
-                    return fetchWithRetry(retryCount + 1);
-                }
-                // 超过最大重试次数，返回错误
-                return {
-                    content: [{ type: 'text', text: `Error fetching JSON from ${url} after ${maxRetries + 1} attempts: ${error}` }],
-                    isError: true
-                };
+            catch (parseError) {
+                // 处理JSON解析错误 (Handle JSON parse error)
+                log('browser.jsonParseError', debug, { error: String(parseError) }, COMPONENTS.BROWSER_FETCH);
+                return BaseFetcher.createErrorResponse(`Error parsing JSON: ${parseError}`);
             }
-        };
-        try {
-            return await fetchWithRetry();
         }
-        finally {
-            // 如果需要关闭浏览器
-            if (closeBrowser) {
-                log('browser.closingInstance', debug, {}, COMPONENTS.BROWSER_FETCH);
-                await BrowserInstance.closeBrowser(debug);
-            }
+        catch (error) {
+            // 处理错误 (Handle error)
+            log('browser.jsonFetchError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+            return BaseFetcher.createErrorResponse(`Error fetching JSON: ${error}`);
         }
     }
     /**
@@ -273,109 +226,96 @@ export class BrowserFetcher {
      * @returns 获取结果 (Fetch result)
      */
     async txt(requestPayload) {
-        const { url, debug = false, closeBrowser = false } = requestPayload;
-        // 如果只是要关闭浏览器，不需要获取内容
-        if (url === 'about:blank' && closeBrowser) {
-            log('browser.closingInstance', debug, {}, COMPONENTS.BROWSER_FETCH);
-            await BrowserInstance.closeBrowser(debug);
-            return {
-                content: [{ type: 'text', text: 'Browser closed successfully' }],
-                isError: false
-            };
+        const { url, debug = false, closeBrowser = false, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, chunkId, startCursor = 0 } = requestPayload;
+        // 如果提供了分段ID和起始游标，则从缓存中获取分段内容 (If chunk ID and startCursor are provided, get chunk content from cache)
+        if (chunkId && startCursor !== undefined) {
+            return this.getChunkContent(chunkId, startCursor, contentSizeLimit, debug, COMPONENTS.BROWSER_FETCH);
         }
-        // 设置最大重试次数
-        const maxRetries = 2;
-        const fetchWithRetry = async (retryCount = 0) => {
-            log('browser.fetchingWithRetry', debug, { attempt: retryCount + 1, maxAttempts: maxRetries + 1, url }, COMPONENTS.BROWSER_FETCH);
-            try {
-                const result = await BrowserFetcher.fetch(requestPayload);
-                // 如果获取成功，提取纯文本
-                if (!result.isError) {
-                    const htmlContent = result.content[0].text;
-                    // 使用JSDOM提取纯文本
-                    const dom = new JSDOM(htmlContent);
-                    const textContent = dom.window.document.body.textContent || '';
-                    // 清理文本（移除多余空白）
-                    const cleanedText = textContent
-                        .replace(/\s+/g, ' ')
-                        .trim();
-                    return {
-                        content: [{ type: 'text', text: cleanedText }],
-                        isError: false
-                    };
-                }
+        log('browser.startingTxtFetch', debug, { url }, COMPONENTS.BROWSER_FETCH);
+        try {
+            // 使用通用的fetch方法获取内容 (Use common fetch method to get content)
+            const result = await BrowserFetcher.fetch(requestPayload);
+            // 如果出错，直接返回错误 (If error, return error directly)
+            if (result.isError) {
                 return result;
             }
-            catch (error) {
-                log('browser.fetchErrorWithAttempt', debug, { error: String(error), attempt: retryCount + 1, maxAttempts: maxRetries + 1 }, COMPONENTS.BROWSER_FETCH);
-                if (retryCount < maxRetries) {
-                    // 计算延迟时间，随着重试次数增加而增加
-                    const delayMs = 1000 * (retryCount + 1);
-                    log('browser.retryingAfterDelay', debug, { delayMs }, COMPONENTS.BROWSER_FETCH);
-                    // 等待一段时间后重试
-                    await new Promise(resolve => setTimeout(resolve, delayMs));
-                    return fetchWithRetry(retryCount + 1);
-                }
-                // 超过最大重试次数，返回错误
-                return {
-                    content: [{ type: 'text', text: `Error fetching text from ${url} after ${maxRetries + 1} attempts: ${error}` }],
-                    isError: true
-                };
+            // 获取HTML内容 (Get HTML content)
+            const html = result.content[0].text;
+            // 使用JSDOM提取纯文本 (Extract plain text using JSDOM)
+            log('browser.extractingText', debug, {}, COMPONENTS.BROWSER_FETCH);
+            const dom = new JSDOM(html);
+            const text = dom.window.document.body.textContent || '';
+            log('browser.textExtracted', debug, { length: text.length }, COMPONENTS.BROWSER_FETCH);
+            // 检查内容大小并处理 (Check content size and process)
+            const chunkingResult = this.handleContentChunking(text, contentSizeLimit, enableContentSplitting, debug, COMPONENTS.BROWSER_FETCH);
+            if (chunkingResult) {
+                return chunkingResult;
             }
-        };
-        try {
-            return await fetchWithRetry();
+            // 返回纯文本内容 (Return plain text content)
+            return BaseFetcher.createSuccessResponse(text);
         }
-        finally {
-            // 如果需要关闭浏览器
-            if (closeBrowser) {
-                log('browser.closingInstance', debug, {}, COMPONENTS.BROWSER_FETCH);
-                await BrowserInstance.closeBrowser(debug);
-            }
+        catch (error) {
+            // 处理错误 (Handle error)
+            log('browser.txtFetchError', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
+            return BaseFetcher.createErrorResponse(`Error fetching text: ${error}`);
         }
     }
     /**
-     * 使用Puppeteer获取Markdown内容 (Get Markdown content using Puppeteer)
-     * 通过浏览器模式获取HTML并转换为Markdown (Fetch HTML in browser mode and convert to Markdown)
+     * 获取HTML并转换为纯文本 (Get HTML and convert to plain text)
      * @param requestPayload 请求参数 (Request parameters)
-     * @returns 获取结果 (Fetch result)
+     * @returns 纯文本响应 (Plain text response)
+     */
+    async plainText(requestPayload) {
+        const { url, debug = false, closeBrowser = false, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, chunkId, startCursor = 0 } = requestPayload;
+        // 如果提供了分段ID和起始游标，则从缓存中获取分段内容 (If chunk ID and startCursor are provided, get chunk content from cache)
+        if (chunkId && startCursor !== undefined) {
+            return this.getChunkContent(chunkId, startCursor, contentSizeLimit, debug, COMPONENTS.BROWSER_FETCH);
+        }
+        log('browser.startingPlainTextFetch', debug, { url: requestPayload.url }, COMPONENTS.BROWSER_FETCH);
+        // 使用HTML方法获取内容 (Use HTML method to get content)
+        const result = await this.html(requestPayload);
+        if (result.isError) {
+            return result;
+        }
+        // 获取HTML内容 (Get HTML content)
+        const html = result.content[0].text;
+        // 使用ContentProcessor将HTML转换为纯文本 (Use ContentProcessor to convert HTML to plain text)
+        const plainText = ContentProcessor.htmlToText(html, debug, COMPONENTS.BROWSER_FETCH);
+        // 检查内容大小并处理 (Check content size and process)
+        const chunkingResult = this.handleContentChunking(plainText, contentSizeLimit, enableContentSplitting, debug, COMPONENTS.BROWSER_FETCH);
+        if (chunkingResult) {
+            return chunkingResult;
+        }
+        // 返回纯文本内容 (Return plain text content)
+        return BaseFetcher.createSuccessResponse(plainText);
+    }
+    /**
+     * 获取HTML并转换为Markdown (Get HTML and convert to Markdown)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns Markdown内容 (Markdown content)
      */
     async markdown(requestPayload) {
-        const { url, debug = false } = requestPayload;
-        log('browser.startingBrowserFetchForMarkdown', debug, { url }, COMPONENTS.BROWSER_FETCH);
-        try {
-            // 获取HTML内容
-            const htmlResult = await this.html(requestPayload);
-            if (htmlResult.isError) {
-                return htmlResult;
-            }
-            // 将HTML转换为Markdown
-            const turndownService = new TurndownService({
-                headingStyle: 'atx',
-                codeBlockStyle: 'fenced',
-                bulletListMarker: '-'
-            });
-            // 添加表格支持
-            turndownService.addRule('tables', {
-                filter: ['table'],
-                replacement: function (content, node) {
-                    const tableContent = content.trim();
-                    return '\n\n' + tableContent + '\n\n';
-                }
-            });
-            // 转换HTML为Markdown
-            const markdown = turndownService.turndown(htmlResult.content[0].text);
-            return {
-                content: [{ type: 'text', text: markdown }],
-                isError: false
-            };
+        const { url, debug = false, closeBrowser = false, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, chunkId, startCursor = 0 } = requestPayload;
+        // 如果提供了分段ID和起始游标，则从缓存中获取分段内容 (If chunk ID and startCursor are provided, get chunk content from cache)
+        if (chunkId && startCursor !== undefined) {
+            return this.getChunkContent(chunkId, startCursor, contentSizeLimit, debug, COMPONENTS.BROWSER_FETCH);
         }
-        catch (error) {
-            log('browser.errorInBrowserFetchForMarkdown', debug, { error: String(error) }, COMPONENTS.BROWSER_FETCH);
-            return {
-                content: [{ type: 'text', text: `Error converting HTML to Markdown for ${url}: ${error}` }],
-                isError: true
-            };
+        log('browser.startingMarkdownFetch', debug, { url: requestPayload.url }, COMPONENTS.BROWSER_FETCH);
+        // 使用HTML方法获取内容 (Use HTML method to get content)
+        const result = await this.html(requestPayload);
+        if (result.isError) {
+            return result;
+        }
+        // 获取HTML内容 (Get HTML content)
+        const html = result.content[0].text;
+        // 使用ContentProcessor将HTML转换为Markdown (Use ContentProcessor to convert HTML to Markdown)
+        const markdown = ContentProcessor.htmlToMarkdown(html, debug, COMPONENTS.BROWSER_FETCH);
+        // 检查内容大小并处理 (Check content size and process)
+        const chunkingResult = this.handleContentChunking(markdown, contentSizeLimit, enableContentSplitting, debug, COMPONENTS.BROWSER_FETCH);
+        if (chunkingResult) {
+            return chunkingResult;
         }
+        // 返回Markdown内容 (Return Markdown content)
+        return BaseFetcher.createSuccessResponse(markdown);
     }
 }

package/dist/src/lib/fetchers/common/BaseFetcher.js

@@ -0,0 +1,203 @@
+/*
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { log } from "../../logger.js";
+import { ContentSizeManager } from "../../utils/ContentSizeManager.js";
+import { ChunkManager } from "../../utils/ChunkManager.js";
+import { TemplateUtils } from "../../utils/TemplateUtils.js";
+/**
+ * 基础获取器类 (Base fetcher class)
+ * 提供所有获取器共用的基础功能 (Provides basic functionality used by all fetchers)
+ */
+export class BaseFetcher {
+    /**
+     * 创建成功响应 (Create success response)
+     * @param content 内容 (Content)
+     * @returns 成功响应 (Success response)
+     */
+    static createSuccessResponse(content) {
+        return {
+            isError: false,
+            content: [
+                {
+                    type: 'text',
+                    text: content
+                }
+            ]
+        };
+    }
+    /**
+     * 创建错误响应 (Create error response)
+     * @param errorMessage 错误信息 (Error message)
+     * @returns 错误响应 (Error response)
+     */
+    static createErrorResponse(errorMessage) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage
+                }
+            ]
+        };
+    }
+    /**
+     * 处理内容分段 (Handle content chunking)
+     * 如果内容超过大小限制，则进行分段处理 (If content exceeds size limit, chunk it)
+     * @param content 内容 (Content)
+     * @param contentSizeLimit 内容大小限制 (Content size limit)
+     * @param enableContentSplitting 是否启用内容分段 (Whether to enable content splitting)
+     * @param debug 是否启用调试输出 (Whether to enable debug output)
+     * @param component 日志组件名称 (Log component name)
+     * @returns 分段处理结果，如果不需要分段则返回null (Chunking result, or null if no chunking needed)
+     */
+    handleContentChunking(content, contentSizeLimit = ContentSizeManager.getDefaultSizeLimit(), enableContentSplitting = true, debug = false, component) {
+        // 检查内容大小 (Check content size)
+        const contentLength = content.length;
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        log('fetcher.contentLength', debug, { length: contentLength, bytes: contentBytes }, component);
+        // 如果内容大小超过限制且启用了内容分段 (If content size exceeds limit and content splitting is enabled)
+        if (contentBytes > contentSizeLimit && enableContentSplitting) {
+            log('fetcher.contentTooLarge', debug, {
+                size: contentBytes,
+                limit: contentSizeLimit
+            }, component);
+            // 分割内容 (Split content)
+            const { chunks, totalBytes } = ContentSizeManager.splitContentIntoChunks(content, contentSizeLimit, debug, 0);
+            // 存储分割后的内容 (Store chunked content)
+            const chunkId = ChunkManager.storeChunks(chunks, totalBytes, debug);
+            // 获取第一个分片 (Get first chunk)
+            const chunkResult = ChunkManager.getChunkBySize(chunkId, 0, contentSizeLimit, debug);
+            if (!chunkResult) {
+                log('fetcher.chunkRetrievalFailed', debug, { chunkId }, component);
+                return BaseFetcher.createErrorResponse("Failed to retrieve chunk content");
+            }
+            const { content: firstChunk, fetchedBytes, remainingBytes, totalBytes: totalSize } = chunkResult;
+            // 计算预计还需要的请求次数 (Calculate estimated number of requests needed)
+            const estimatedRequests = Math.ceil(remainingBytes / contentSizeLimit);
+            // 添加分段提示 (Add chunk prompt)
+            const isFirstRequest = true;
+            const chunkWithPrompt = firstChunk + TemplateUtils.generateSizeBasedChunkPrompt(fetchedBytes, totalSize, chunkId, remainingBytes, estimatedRequests, contentSizeLimit, isFirstRequest);
+            // 创建响应 (Create response)
+            return {
+                isError: false,
+                isChunked: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: chunkWithPrompt
+                    }
+                ],
+                chunkId,
+                totalBytes: totalSize,
+                fetchedBytes,
+                remainingBytes,
+                hasMoreChunks: remainingBytes > 0
+            };
+        }
+        // 如果内容大小超过限制但未启用内容分段 (If content size exceeds limit but content splitting is not enabled)
+        if (contentBytes > contentSizeLimit && !enableContentSplitting) {
+            log('fetcher.contentTruncated', debug, {
+                originalBytes: contentBytes,
+                truncatedLength: contentSizeLimit
+            }, component);
+            const truncatedContent = content.substring(0, contentSizeLimit);
+            return BaseFetcher.createSuccessResponse(truncatedContent + `\n\n${TemplateUtils.SYSTEM_NOTE.START}\nContent was too large (${contentBytes} bytes) and has been truncated to ${contentSizeLimit} bytes. Enable content splitting to view the full content.\n${TemplateUtils.SYSTEM_NOTE.END}`);
+        }
+        // 如果不需要分段，返回null (If no chunking needed, return null)
+        return null;
+    }
+    /**
+     * 获取分段内容 - 基于字节偏移量 (Get chunked content based on byte offset)
+     * @param chunkId 分段ID (Chunk ID)
+     * @param startCursor 开始游标位置 (Start cursor position)
+     * @param sizeLimit 大小限制 (Size limit)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @param component 日志组件名称 (Log component name)
+     * @returns 获取结果 (Fetch result)
+     */
+    getChunkContent(chunkId, startCursor = 0, sizeLimit = ContentSizeManager.getDefaultSizeLimit(), debug = false, component) {
+        log('fetcher.gettingChunkBySize', debug, {
+            chunkId,
+            startCursor,
+            start: startCursor,
+            end: startCursor + sizeLimit,
+            sizeLimit
+        }, component);
+        // 获取分段内容 (Get chunked content)
+        const chunkResult = ChunkManager.getChunkBySize(chunkId, startCursor, sizeLimit, debug);
+        // 如果获取失败，返回错误 (If retrieval failed, return error)
+        if (!chunkResult) {
+            log('fetcher.chunkNotFound', debug, { chunkId, startCursor }, component);
+            return BaseFetcher.createErrorResponse(`Chunk with ID ${chunkId} at cursor position ${startCursor} not found`);
+        }
+        // 获取相关信息 (Get related information)
+        const { content, fetchedBytes, remainingBytes, isLastChunk, totalBytes } = chunkResult;
+        // 计算预计还需要的请求次数 (Calculate estimated number of requests needed)
+        const estimatedRequests = Math.ceil(remainingBytes / sizeLimit);
+        // 添加分段提示 (Add chunk prompt)
+        let contentWithPrompt;
+        if (isLastChunk) {
+            // 如果是最后一个分段 (If it's the last chunk)
+            contentWithPrompt = content + TemplateUtils.generateSizeBasedLastChunkPrompt(fetchedBytes, totalBytes, startCursor === 0 // 如果startCursor为0，则为首次请求 (If startCursor is 0, it's the first request)
+            );
+        }
+        else {
+            // 如果不是最后一个分段 (If it's not the last chunk)
+            contentWithPrompt = content + TemplateUtils.generateSizeBasedChunkPrompt(fetchedBytes, totalBytes, chunkId, remainingBytes, estimatedRequests, sizeLimit, startCursor === 0 // 如果startCursor为0，则为首次请求 (If startCursor is 0, it's the first request)
+            );
+        }
+        // 创建响应 (Create response)
+        return {
+            isError: false,
+            isChunked: true,
+            content: [
+                {
+                    type: 'text',
+                    text: contentWithPrompt
+                }
+            ],
+            chunkId,
+            totalBytes,
+            fetchedBytes,
+            remainingBytes,
+            hasMoreChunks: !isLastChunk
+        };
+    }
+    /**
+     * 添加分段提示词 (Add chunk prompt)
+     * @param response 响应对象 (Response object)
+     * @returns 添加了提示词的响应对象 (Response object with prompt)
+     */
+    static addChunkPrompt(response) {
+        // 检查是否存在字节信息并需要添加分块提示 (Check if byte information exists and need to add chunk prompt)
+        if (response.isChunked && response.hasMoreChunks && response.totalBytes && response.fetchedBytes && response.remainingBytes) {
+            const chunkId = response.chunkId || '';
+            const currentSizeLimit = response.fetchedBytes; // 假设当前大小限制与已获取字节数相同 (Assume current size limit is the same as fetched bytes)
+            const estimatedRequests = Math.ceil(response.remainingBytes / currentSizeLimit);
+            // 检查内容中是否已经包含系统提示 (Check if content already contains system note)
+            if (TemplateUtils.hasSystemPrompt(response.content[0].text || '')) {
+                // 已存在提示，直接返回原始响应 (Note already exists, return original response)
+                return response;
+            }
+            // 使用基于字节的提示 (Use byte-based prompt)
+            const promptText = TemplateUtils.generateSizeBasedChunkPrompt(response.fetchedBytes, response.totalBytes, chunkId, response.remainingBytes, estimatedRequests, currentSizeLimit, false // 设置为false表示这不是首次请求 (Set to false indicating this is not the first request)
+            );
+            // 创建新的响应对象，避免修改原始对象 (Create new response object to avoid modifying the original)
+            return {
+                ...response,
+                content: [
+                    {
+                        type: 'text',
+                        text: (response.content[0].text || '') + promptText
+                    }
+                ]
+            };
+        }
+        // 如果不需要添加提示，返回原始响应 (If no prompt needed, return original response)
+        return response;
+    }
+}