@anyul/koishi-plugin-rss 5.2.3 → 5.2.41

package/lib/core/notification-queue.js

@@ -1,46 +1,12 @@
 "use strict";
-/**
- * 消息发送队列管理器
- * 实现可靠的消息推送，支持重试、降级和错误处理
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationQueueManager = void 0;
 const error_handler_1 = require("../utils/error-handler");
 const error_tracker_1 = require("../utils/error-tracker");
 const logger_1 = require("../utils/logger");
+const notification_queue_retry_1 = require("./notification-queue-retry");
+const notification_queue_sender_1 = require("./notification-queue-sender");
+const notification_queue_store_1 = require("./notification-queue-store");
 /**
  * 消息发送队列管理器
  */
@@ -48,13 +14,27 @@ class NotificationQueueManager {
     ctx;
     config;
     processing = false;
-    maxRetries = 5;
-    batchSize = 10;
-    // 指数退避时间（秒）：10s, 30s, 1m, 5m, 10m
-    backoffDelays = [10, 30, 60, 300, 600];
+    recovered = false;
+    batchSize;
+    maxRetries;
+    cleanupHours;
+    store;
+    sender;
+    backoffDelays = notification_queue_retry_1.DEFAULT_QUEUE_BACKOFF_DELAYS;
     constructor(ctx, config) {
         this.ctx = ctx;
         this.config = config;
+        const runtimeConfig = (0, notification_queue_retry_1.getQueueRuntimeConfig)(config);
+        this.batchSize = runtimeConfig.batchSize;
+        this.maxRetries = runtimeConfig.maxRetries;
+        this.cleanupHours = runtimeConfig.cleanupHours;
+        this.store = new notification_queue_store_1.NotificationQueueStore(ctx, this.batchSize);
+        this.sender = new notification_queue_sender_1.NotificationQueueSender({
+            ctx,
+            config,
+            createTaskDebug: task => this.createTaskDebug(task),
+            buildTaskLogContext: task => this.buildTaskLogContext(task),
+        });
     }
     buildTaskLogContext(task) {
         const context = {
@@ -80,18 +60,32 @@ class NotificationQueueManager {
      * 添加任务到队列
      */
     async addTask(task) {
-        const queueTask = {
-            ...task,
-            status: 'PENDING',
-            retryCount: 0,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        };
+        const { task: queueTask, created } = await this.store.createTask(task);
         const taskDebug = this.createTaskDebug(queueTask);
-        await this.ctx.database.create('rss_notification_queue', queueTask);
+        if (!created) {
+            taskDebug(`检测到重复任务，跳过入队: [${task.rssId}] ${task.content.title || task.uid}`, 'queue', 'info', {
+                duplicate: true,
+            });
+            return queueTask;
+        }
         taskDebug(`任务已加入队列: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
         return queueTask;
     }
+    isProcessing() {
+        return this.processing;
+    }
+    async ensureRecovered() {
+        if (this.recovered) {
+            return;
+        }
+        const recoveredCount = await this.store.recoverRetryTasksWithoutNextRetryTime();
+        this.recovered = true;
+        if (recoveredCount > 0) {
+            (0, logger_1.debug)(this.config, `已恢复 ${recoveredCount} 个缺少下次重试时间的任务`, 'queue', 'info', {
+                recoveredCount,
+            });
+        }
+    }
     /**
      * 处理队列中的任务
      */
@@ -102,13 +96,12 @@ class NotificationQueueManager {
         }
         this.processing = true;
         try {
-            // 1. 查找待处理任务
-            const tasks = await this.getPendingTasks();
+            await this.ensureRecovered();
+            const tasks = await this.store.getPendingTasks();
             if (tasks.length === 0) {
                 return;
             }
             (0, logger_1.debug)(this.config, `开始处理 ${tasks.length} 个待发送任务`, 'queue', 'info', { taskCount: tasks.length });
-            // 2. 逐个处理任务
             for (const task of tasks) {
                 await this.processTask(task);
             }
@@ -122,22 +115,6 @@ class NotificationQueueManager {
             this.processing = false;
         }
     }
-    /**
-     * 获取待处理任务
-     */
-    async getPendingTasks() {
-        const now = new Date();
-        // 获取所有 PENDING 状态的任务
-        const pendingTasks = await this.ctx.database.get('rss_notification_queue', { status: 'PENDING' }, { limit: this.batchSize });
-        // 获取到达重试时间的 RETRY 状态任务
-        const retryTasks = await this.ctx.database.get('rss_notification_queue', { status: 'RETRY' }, { limit: this.batchSize });
-        // 过滤出到达重试时间的任务
-        const readyRetryTasks = retryTasks.filter(task => task.nextRetryTime && new Date(task.nextRetryTime) <= now);
-        // 合并并按创建时间排序
-        return [...pendingTasks, ...readyRetryTasks]
-            .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime())
-            .slice(0, this.batchSize);
-    }
     /**
      * 处理单个任务
      */
@@ -145,75 +122,56 @@ class NotificationQueueManager {
         const taskDebug = this.createTaskDebug(task);
         taskDebug(`处理任务 [${task.rssId}] ${task.content.title} (重试${task.retryCount}次)`, 'queue', 'details');
         try {
-            // 尝试发送消息
-            await this.sendMessage(task);
-            // 发送成功：标记为 SUCCESS
-            await this.markTaskSuccess(task.id);
+            await this.sender.sendMessage(task);
+            await this.store.markTaskSuccess(task.id);
             taskDebug(`✓ 任务发送成功: [${task.rssId}] ${task.content.title}`, 'queue', 'info');
-            // 写入缓存
-            await this.cacheMessage(task);
+            await this.sender.cacheMessage(task);
         }
         catch (error) {
-            // 进入错误处理流程
             await this.handleSendError(task, error);
         }
     }
-    /**
-     * 发送消息（带降级机制）
-     */
-    async sendMessage(task) {
-        const { guildId, platform, content } = task;
-        const target = `${platform}:${guildId}`;
-        const taskDebug = this.createTaskDebug(task);
-        try {
-            // 第一次尝试：发送原始消息
-            await this.ctx.broadcast([target], content.message);
-            taskDebug(`消息发送成功: ${target}`, 'queue', 'details');
-        }
-        catch (sendError) {
-            // OneBot retcode 1200: 不支持的消息格式（通常是视频）
-            const isOneBot1200 = sendError.code?.toString?.() === '1200' || sendError.message?.includes('1200');
-            if (isOneBot1200 && !content.isDowngraded) {
-                taskDebug(`检测到 OneBot 1200 错误，尝试降级处理`, 'queue', 'info', { errorCode: '1200' });
-                throw { ...sendError, isMediaError: true, requiresDowngrade: true };
-            }
-            throw sendError;
-        }
-    }
     /**
      * 处理发送错误
      */
     async handleSendError(task, error) {
         const taskDebug = this.createTaskDebug(task);
-        const normalizedError = (0, error_handler_1.normalizeError)(error);
+        const classification = (0, notification_queue_retry_1.classifyQueueError)(error, task.content);
+        const normalizedError = classification.normalizedError;
         const errorMsg = normalizedError.message || 'Unknown error';
         (0, error_tracker_1.trackError)(normalizedError, {
             ...this.buildTaskLogContext(task),
             failReason: errorMsg,
-            requiresDowngrade: Boolean(error?.requiresDowngrade),
+            queueErrorAction: classification.action,
         });
-        // 1. 永久性错误 (Fatal) - 不需要重试
-        if (this.isFatalError(error)) {
-            await this.markTaskFailed(task.id, errorMsg);
+        if (classification.action === 'FAILED') {
+            await this.store.markTaskFailed(task.id, errorMsg);
             taskDebug(`✗ 永久性失败，放弃重试: [${task.rssId}] ${task.content.title} - ${errorMsg}`, 'queue', 'error', {
                 fatal: true,
                 failReason: errorMsg,
             });
             return;
         }
-        // 2. 降级重试 (Downgrade) - 针对媒体格式错误
-        if (error.requiresDowngrade && !task.content.isDowngraded) {
+        if (classification.action === 'DOWNGRADE') {
             const downgradedContent = await this.downgradeMessage(task.content);
-            await this.updateTaskForDowngrade(task, downgradedContent);
+            await this.store.updateTaskForDowngrade(task, downgradedContent);
             taskDebug(`→ 消息已降级，立即重试: [${task.rssId}] ${task.content.title}`, 'queue', 'info', {
-                requiresDowngrade: true,
+                queueErrorAction: classification.action,
             });
             return;
         }
-        // 3. 暂时性错误 (Transient) - 使用指数退避
-        const delay = this.backoffDelays[task.retryCount] || this.backoffDelays[this.backoffDelays.length - 1];
+        if ((0, notification_queue_retry_1.shouldStopRetrying)(task.retryCount, this.maxRetries)) {
+            const maxRetryMessage = `超过最大重试次数(${this.maxRetries}): ${errorMsg}`;
+            await this.store.markTaskFailed(task.id, maxRetryMessage);
+            taskDebug(`✗ 已达到最大重试次数，任务失败: [${task.rssId}] ${task.content.title} - ${errorMsg}`, 'queue', 'error', {
+                maxRetries: this.maxRetries,
+                failReason: maxRetryMessage,
+            });
+            return;
+        }
+        const delay = (0, notification_queue_retry_1.getRetryDelaySeconds)(task.retryCount, this.backoffDelays);
         const nextTime = new Date(Date.now() + delay * 1000);
-        await this.markTaskRetry(task, nextTime, errorMsg);
+        await this.store.markTaskRetry(task, nextTime, errorMsg);
         taskDebug(`→ 任务将在 ${Math.ceil(delay / 60)} 分钟后重试: [${task.rssId}] ${task.content.title}`, 'queue', 'info', {
             nextRetryTime: nextTime.toISOString(),
             failReason: errorMsg,
@@ -223,177 +181,42 @@ class NotificationQueueManager {
      * 判断是否为永久性错误
      */
     isFatalError(error) {
-        const errorCode = error.code || error.retcode;
-        // 群组不存在 / 账号不在群内
-        if (errorCode === 'UnknownGroup' || errorCode === 'GROUP_NOT_FOUND') {
-            return true;
-        }
-        // 账号被封禁 / 被拉黑
-        if (errorCode === 'UserBlock' || errorCode === 'BANNED') {
-            return true;
-        }
-        // 权限不足
-        if (errorCode === 'PermissionDenied' || errorCode === 'NO_PERMISSION') {
-            return true;
-        }
-        // 超过最大重试次数
-        // 这个判断在调用处处理
-        return false;
+        return (0, notification_queue_retry_1.isFatalQueueError)(error);
     }
     /**
      * 降级消息（移除媒体元素）
      */
     async downgradeMessage(content) {
-        // 移除 video 元素，保留视频链接
-        let downgradedMessage = content.message.replace(/<video[^>]*>.*?<\/video>/gis, (match) => {
-            const srcMatch = match.match(/src=["']([^"']+)["']/);
-            if (srcMatch) {
-                return `\n🎬 视频: ${srcMatch[1]}\n`;
-            }
-            return '\n[视频不支持]\n';
-        });
-        // 移除 img 元素，保留图片链接（可选）
-        // downgradedMessage = downgradedMessage.replace(/<img[^>]*>/gis, (match: string) => {
-        //   const srcMatch = match.match(/src=["']([^"']+)["']/)
-        //   if (srcMatch) {
-        //     return `\n🖼️ 图片: ${srcMatch[1]}\n`
-        //   }
-        //   return '\n[图片不支持]\n'
-        // })
-        return {
-            ...content,
-            message: downgradedMessage,
-            isDowngraded: true
-        };
-    }
-    /**
-     * 标记任务为成功
-     */
-    async markTaskSuccess(taskId) {
-        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
-            status: 'SUCCESS',
-            updatedAt: new Date()
-        });
-        // 可选：定期清理成功任务，避免数据库膨胀
-        // await this.ctx.database.remove(('rss_notification_queue' as any), { id: taskId })
-    }
-    /**
-     * 标记任务为重试
-     */
-    async markTaskRetry(task, nextTime, reason) {
-        await this.ctx.database.set('rss_notification_queue', { id: task.id }, {
-            status: 'RETRY',
-            nextRetryTime: nextTime,
-            retryCount: (task.retryCount || 0) + 1,
-            failReason: reason,
-            updatedAt: new Date()
-        });
-    }
-    /**
-     * 更新任务为降级重试
-     */
-    async updateTaskForDowngrade(task, newContent) {
-        await this.ctx.database.set('rss_notification_queue', { id: task.id }, {
-            content: newContent,
-            status: 'RETRY',
-            nextRetryTime: new Date(), // 立即重试
-            retryCount: (task.retryCount || 0) + 1,
-            updatedAt: new Date()
-        });
-    }
-    /**
-     * 标记任务为失败
-     */
-    async markTaskFailed(taskId, reason) {
-        await this.ctx.database.set('rss_notification_queue', { id: taskId }, {
-            status: 'FAILED',
-            failReason: reason,
-            updatedAt: new Date()
-        });
-    }
-    /**
-     * 缓存成功发送的消息
-     */
-    async cacheMessage(task) {
-        if (!this.config.cache?.enabled) {
-            return;
-        }
-        const taskDebug = this.createTaskDebug(task);
-        const { getMessageCache } = await Promise.resolve().then(() => __importStar(require('../utils/message-cache')));
-        const cache = getMessageCache();
-        if (!cache) {
-            return;
-        }
-        try {
-            await cache.addMessage({
-                rssId: task.rssId,
-                guildId: task.guildId,
-                platform: task.platform,
-                title: task.content.title || '',
-                content: task.content.description || '',
-                link: task.content.link || '',
-                pubDate: task.content.pubDate || new Date(),
-                imageUrl: task.content.imageUrl || '',
-                videoUrl: '',
-                finalMessage: task.content.message
-            });
-        }
-        catch (err) {
-            const normalizedError = (0, error_handler_1.normalizeError)(err);
-            taskDebug(`缓存消息失败: ${normalizedError.message}`, 'cache', 'info');
-            (0, error_tracker_1.trackError)(normalizedError, {
-                ...this.buildTaskLogContext(task),
-                operation: 'cacheMessage',
-            });
-        }
+        return this.sender.downgradeMessage(content);
     }
     /**
      * 获取队列统计信息
      */
     async getStats() {
-        const allTasks = await this.ctx.database.get('rss_notification_queue', {});
-        return {
-            pending: allTasks.filter((t) => t.status === 'PENDING').length,
-            retry: allTasks.filter((t) => t.status === 'RETRY').length,
-            failed: allTasks.filter((t) => t.status === 'FAILED').length,
-            success: allTasks.filter((t) => t.status === 'SUCCESS').length
-        };
+        return this.store.getStats();
     }
     /**
      * 重试失败的任务
      */
     async retryFailedTasks(taskId) {
-        const where = taskId ? { id: taskId } : { status: 'FAILED' };
-        const tasks = await this.ctx.database.get('rss_notification_queue', where);
-        const failedTasks = tasks.filter(task => task.status === 'FAILED');
-        for (const task of failedTasks) {
-            await this.ctx.database.set('rss_notification_queue', { id: task.id }, {
-                status: 'PENDING',
-                retryCount: 0,
-                failReason: null,
-                updatedAt: new Date()
-            });
-        }
-        (0, logger_1.debug)(this.config, `已重置 ${failedTasks.length} 个失败任务为 PENDING 状态`, 'queue', 'info', {
-            resetCount: failedTasks.length,
+        const resetCount = await this.store.retryFailedTasks(taskId);
+        (0, logger_1.debug)(this.config, `已重置 ${resetCount} 个失败任务为 PENDING 状态`, 'queue', 'info', {
+            resetCount,
             taskId,
         });
-        return failedTasks.length;
+        return resetCount;
     }
     /**
      * 清理旧的成功任务
      */
-    async cleanupSuccessTasks(olderThanHours = 24) {
-        const cutoffTime = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
-        const tasks = await this.ctx.database.get('rss_notification_queue', { status: 'SUCCESS', updatedAt: { $lt: cutoffTime } });
-        for (const task of tasks) {
-            await this.ctx.database.remove('rss_notification_queue', { id: task.id });
-        }
-        (0, logger_1.debug)(this.config, `已清理 ${tasks.length} 个旧的成功任务`, 'queue', 'info', {
-            cleanupCount: tasks.length,
-            olderThanHours,
+    async cleanupSuccessTasks(olderThanHours) {
+        const cleanupHours = olderThanHours ?? this.cleanupHours;
+        const cleanupCount = await this.store.cleanupSuccessTasks(cleanupHours);
+        (0, logger_1.debug)(this.config, `已清理 ${cleanupCount} 个旧的成功任务`, 'queue', 'info', {
+            cleanupCount,
+            olderThanHours: cleanupHours,
         });
-        return tasks.length;
+        return cleanupCount;
     }
 }
 exports.NotificationQueueManager = NotificationQueueManager;

package/lib/core/search-format.d.ts

@@ -0,0 +1,3 @@
+import { SearchResponse } from './search-types';
+export declare function formatSearchResults(response: SearchResponse): string;
+export declare function buildPromptWithSearchContext(originalPrompt: string, searchResults: SearchResponse, searchQuery: string): string;

package/lib/core/search-format.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSearchResults = formatSearchResults;
+exports.buildPromptWithSearchContext = buildPromptWithSearchContext;
+function formatSearchResults(response) {
+    if (!response.success || response.results.length === 0) {
+        return '';
+    }
+    const lines = [];
+    lines.push(`\n联网搜索结果 (${response.engine}):\n`);
+    response.results.forEach((result, index) => {
+        lines.push(`${index + 1}. ${result.title}`);
+        lines.push(`   链接: ${result.url}`);
+        if (result.snippet) {
+            lines.push(`   摘要: ${result.snippet}`);
+        }
+        if (result.publishedDate) {
+            lines.push(`   发布时间: ${result.publishedDate}`);
+        }
+        lines.push('');
+    });
+    return lines.join('\n');
+}
+function buildPromptWithSearchContext(originalPrompt, searchResults, searchQuery) {
+    if (!searchResults.success || searchResults.results.length === 0) {
+        return originalPrompt;
+    }
+    const formattedResults = formatSearchResults(searchResults);
+    return `${originalPrompt}
+
+${formattedResults}
+
+【搜索结果使用原则】：
+1. 若 RSS 原始内容残缺，请使用以上搜索结果进行补全。
+2. 搜索结果仅作为背景参考，若搜索结果中的人物、时间、事件与 RSS 原文冲突，**必须以 RSS 原文为准**！请提取并生成一份事实准确、语言简洁流畅的摘要。`;
+}

package/lib/core/search-providers.d.ts

@@ -0,0 +1,13 @@
+import { Config, SearchConfig } from '../types';
+import { SearchResponse } from './search-types';
+export declare function searchWithTavily(config: Config, query: string, apiKey: string, options?: {
+    maxResults?: number;
+    searchDepth?: 'basic' | 'advanced';
+    includeAnswer?: boolean;
+}): Promise<SearchResponse>;
+export declare function searchWithSearxng(config: Config, query: string, instanceUrl: string, options?: {
+    maxResults?: number;
+    language?: string;
+    categories?: Array<'general' | 'news' | 'images' | 'videos'>;
+}): Promise<SearchResponse>;
+export declare function searchWithVolcengine(config: Config, query: string, baseUrl: string, apiKey: string, model?: string, searchConfig?: SearchConfig): Promise<SearchResponse>;

package/lib/core/search-providers.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchWithTavily = searchWithTavily;
+exports.searchWithSearxng = searchWithSearxng;
+exports.searchWithVolcengine = searchWithVolcengine;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../utils/logger");
+const proxy_1 = require("../utils/proxy");
+const search_rotation_1 = require("./search-rotation");
+async function searchWithTavily(config, query, apiKey, options) {
+    try {
+        (0, logger_1.debug)(config, `使用 Tavily 搜索: ${query}`, 'Search-Tavily', 'info');
+        const requestConfig = {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            timeout: config.ai?.timeout || 30000,
+            ...(0, proxy_1.buildAxiosProxyConfig)(config)
+        };
+        const response = await axios_1.default.post('https://api.tavily.com/search', {
+            query,
+            max_results: options?.maxResults || 5,
+            search_depth: options?.searchDepth || 'basic',
+            include_answer: options?.includeAnswer !== false,
+            include_raw_content: false
+        }, requestConfig);
+        const results = response.data.results.map(item => ({
+            title: item.title,
+            url: item.url,
+            content: item.content,
+            snippet: item.content.substring(0, 200) + '...',
+            score: item.score,
+            publishedDate: item.published_date,
+            source: 'tavily'
+        }));
+        (0, logger_1.debug)(config, `Tavily 搜索成功，找到 ${results.length} 条结果`, 'Search-Tavily', 'details');
+        return {
+            success: true,
+            results,
+            query,
+            engine: 'tavily'
+        };
+    }
+    catch (error) {
+        const errorMsg = `Tavily 搜索失败: ${error.message}`;
+        (0, logger_1.debug)(config, errorMsg, 'Search-Tavily', 'error');
+        return {
+            success: false,
+            results: [],
+            query,
+            engine: 'tavily',
+            error: errorMsg
+        };
+    }
+}
+async function searchWithSearxng(config, query, instanceUrl, options) {
+    try {
+        (0, logger_1.debug)(config, `使用 SearXNG 搜索: ${query}`, 'Search-SearXNG', 'info');
+        const baseUrl = instanceUrl.replace(/\/+$/, '');
+        const requestConfig = {
+            timeout: config.ai?.timeout || 30000,
+            ...(0, proxy_1.buildAxiosProxyConfig)(config)
+        };
+        const response = await axios_1.default.get(`${baseUrl}/search`, {
+            ...requestConfig,
+            params: {
+                q: query,
+                format: 'json',
+                language: options?.language || 'all',
+                categories: options?.categories?.join(',') || 'general'
+            }
+        });
+        const maxResults = options?.maxResults || 5;
+        const results = response.data.results
+            .slice(0, maxResults)
+            .map(item => ({
+            title: item.title,
+            url: item.url,
+            content: item.content,
+            snippet: item.snippet || item.content.substring(0, 200) + '...',
+            score: item.score,
+            source: `searxng-${item.engine || 'unknown'}`
+        }));
+        (0, logger_1.debug)(config, `SearXNG 搜索成功，找到 ${results.length} 条结果`, 'Search-SearXNG', 'details');
+        return {
+            success: true,
+            results,
+            query,
+            engine: 'searxng'
+        };
+    }
+    catch (error) {
+        const errorMsg = `SearXNG 搜索失败: ${error.message}`;
+        (0, logger_1.debug)(config, errorMsg, 'Search-SearXNG', 'error');
+        return {
+            success: false,
+            results: [],
+            query,
+            engine: 'searxng',
+            error: errorMsg
+        };
+    }
+}
+async function searchWithVolcengine(config, query, baseUrl, apiKey, model, searchConfig = {}) {
+    const actualModel = model || (0, search_rotation_1.getNextVolcengineModel)(config, searchConfig);
+    try {
+        (0, logger_1.debug)(config, `使用火山引擎搜索: ${query} (模型: ${actualModel})`, 'Search-Volcengine', 'info');
+        const requestConfig = {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            timeout: config.ai?.timeout || 30000,
+            ...(0, proxy_1.buildAxiosProxyConfig)(config)
+        };
+        const response = await axios_1.default.post(`${baseUrl.replace(/\/+$/, '')}/responses`, {
+            model: actualModel,
+            input: [{ role: 'user', content: query }],
+            tools: [{ type: 'web_search' }]
+        }, requestConfig);
+        const searchResults = [];
+        if (response.data?.output && Array.isArray(response.data.output)) {
+            for (const outputItem of response.data.output) {
+                if (outputItem.type === 'message' &&
+                    outputItem.role === 'assistant' &&
+                    outputItem.content &&
+                    Array.isArray(outputItem.content)) {
+                    for (const contentItem of outputItem.content) {
+                        if (contentItem.type === 'output_text' &&
+                            contentItem.annotations &&
+                            Array.isArray(contentItem.annotations)) {
+                            for (const annotation of contentItem.annotations) {
+                                if (annotation.type === 'url_citation') {
+                                    searchResults.push({
+                                        title: annotation.title || '',
+                                        url: annotation.url || '',
+                                        content: annotation.summary || '',
+                                        snippet: `${(annotation.summary || '').substring(0, 200)}...`,
+                                        source: annotation.site_name || 'volcengine',
+                                        publishedDate: annotation.publish_time || undefined
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        (0, logger_1.debug)(config, `火山引擎搜索成功，找到 ${searchResults.length} 条结果 (模型: ${actualModel})`, 'Search-Volcengine', 'details');
+        return {
+            success: true,
+            results: searchResults,
+            query,
+            engine: 'volcengine',
+            model: actualModel
+        };
+    }
+    catch (error) {
+        const errorMsg = `火山引擎搜索失败: ${error.message}`;
+        (0, logger_1.debug)(config, errorMsg, 'Search-Volcengine', 'error');
+        (0, search_rotation_1.markVolcengineModelFailure)(config, searchConfig, actualModel);
+        return {
+            success: false,
+            results: [],
+            query,
+            engine: 'volcengine',
+            model: actualModel,
+            error: errorMsg
+        };
+    }
+}