@cicctencent/agent-midway 0.1.1

package/dist/tools/text-process.tool.js

@@ -0,0 +1,366 @@
+"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.computeHashTool = exports.encodeDecodeTool = exports.textProcessTool = void 0;
+/**
+ * 文本处理工具
+ *
+ * 让 Agent 能够执行各种文本处理操作：正则匹配/替换、编解码、Hash 计算、文本统计等。
+ *
+ * 工具说明：
+ * - text_process：综合文本处理（正则匹配、替换、提取、统计）
+ * - encode_decode：编码/解码（Base64、URL、Unicode、Hex）
+ * - compute_hash：计算文本 Hash（MD5、SHA1、SHA256、SHA512）
+ *
+ * 使用场景：
+ * - 从大段文本中提取结构化信息（邮箱、电话、URL 等）
+ * - 数据格式转换与编解码
+ * - 文本清洗与预处理
+ * - 内容完整性校验（Hash）
+ */
+const crypto = __importStar(require("crypto"));
+// ===================== 正则匹配/替换 =====================
+/** 内置常用正则模板 */
+const BUILTIN_PATTERNS = {
+    email: /[\w.+-]+@[\w-]+\.[\w.-]+/g,
+    url: /https?:\/\/[^\s<>"{}|\\^`[\]]+/g,
+    phone_cn: /1[3-9]\d{9}/g,
+    ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+    date_iso: /\d{4}-\d{2}-\d{2}/g,
+    number: /-?\d+(?:\.\d+)?/g,
+    chinese: /[\u4e00-\u9fa5]+/g,
+    json_block: /\{[\s\S]*?\}|\[[\s\S]*?\]/g,
+};
+function processText(text, operation, pattern, replacement, flags, template) {
+    switch (operation) {
+        case 'match': {
+            const regex = pattern ? new RegExp(pattern, flags || 'g') : null;
+            if (!regex)
+                return { error: 'match 操作需要提供 pattern 参数' };
+            const matches = [];
+            let m;
+            while ((m = regex.exec(text)) !== null && matches.length < 100) {
+                matches.push({
+                    value: m[0],
+                    index: m.index,
+                    groups: m.groups ? { ...m.groups } : undefined,
+                });
+                if (!regex.global)
+                    break;
+            }
+            return {
+                operation: 'match',
+                totalMatches: matches.length,
+                matches,
+            };
+        }
+        case 'replace': {
+            if (!pattern)
+                return { error: 'replace 操作需要提供 pattern 参数' };
+            const regex = new RegExp(pattern, flags || 'g');
+            const result = text.replace(regex, replacement || '');
+            return { operation: 'replace', result, changed: result !== text };
+        }
+        case 'extract': {
+            // 使用内置模板快速提取
+            const templateName = (template || pattern || '').toLowerCase();
+            const regex = BUILTIN_PATTERNS[templateName] ||
+                (pattern ? new RegExp(pattern, flags || 'g') : null);
+            if (!regex)
+                return {
+                    error: 'extract 操作需要提供 pattern 或 template 参数',
+                };
+            const items = [];
+            let m;
+            const r = new RegExp(regex.source, regex.flags.includes('g') ? regex.flags : regex.flags + 'g');
+            while ((m = r.exec(text)) !== null && items.length < 200) {
+                if (!items.includes(m[0]))
+                    items.push(m[0]);
+            }
+            return {
+                operation: 'extract',
+                template: templateName,
+                totalUnique: items.length,
+                items,
+            };
+        }
+        case 'split': {
+            if (!pattern)
+                return { error: 'split 操作需要提供 pattern（分隔符）参数' };
+            const parts = text.split(new RegExp(pattern, flags || ''));
+            return {
+                operation: 'split',
+                totalParts: parts.length,
+                parts: parts.slice(0, 200),
+            };
+        }
+        case 'stats': {
+            const chars = text.length;
+            const lines = text.split('\n').length;
+            const words = text.trim().split(/\s+/).filter(Boolean).length;
+            const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
+            const englishWords = (text.match(/[a-zA-Z]+/g) || []).length;
+            const numbers = (text.match(/\d+/g) || []).length;
+            const sentences = (text.match(/[.!?。！？]+/g) || []).length;
+            return {
+                operation: 'stats',
+                characters: chars,
+                charactersNoSpaces: chars - (text.match(/\s/g) || []).length,
+                lines,
+                words,
+                sentences,
+                chineseCharacters: chineseChars,
+                englishWords,
+                numbers,
+                paragraphs: text.split(/\n\s*\n/).filter(p => p.trim()).length,
+            };
+        }
+        default:
+            return { error: `不支持的操作: ${operation}` };
+    }
+}
+function encodeDecode(text, operation) {
+    try {
+        switch (operation) {
+            case 'base64_encode':
+                return {
+                    operation,
+                    result: Buffer.from(text, 'utf-8').toString('base64'),
+                };
+            case 'base64_decode':
+                return {
+                    operation,
+                    result: Buffer.from(text, 'base64').toString('utf-8'),
+                };
+            case 'url_encode':
+                return { operation, result: encodeURIComponent(text) };
+            case 'url_decode':
+                return { operation, result: decodeURIComponent(text) };
+            case 'unicode_escape':
+                return {
+                    operation,
+                    result: text.replace(/[^\x20-\x7E]/g, ch => `\\u${ch
+                        .charCodeAt(0)
+                        .toString(16)
+                        .padStart(4, '0')}`),
+                };
+            case 'unicode_unescape':
+                return {
+                    operation,
+                    result: text.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16))),
+                };
+            case 'hex_encode':
+                return {
+                    operation,
+                    result: Buffer.from(text, 'utf-8').toString('hex'),
+                };
+            case 'hex_decode':
+                return {
+                    operation,
+                    result: Buffer.from(text, 'hex').toString('utf-8'),
+                };
+            case 'html_escape':
+                return {
+                    operation,
+                    result: text
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/>/g, '&gt;')
+                        .replace(/"/g, '&quot;')
+                        .replace(/'/g, '&#39;'),
+                };
+            case 'html_unescape':
+                return {
+                    operation,
+                    result: text
+                        .replace(/&amp;/g, '&')
+                        .replace(/&lt;/g, '<')
+                        .replace(/&gt;/g, '>')
+                        .replace(/&quot;/g, '"')
+                        .replace(/&#39;/g, "'"),
+                };
+            default:
+                return {
+                    operation,
+                    result: '',
+                    error: `不支持的编解码操作: ${operation}`,
+                };
+        }
+    }
+    catch (e) {
+        return {
+            operation,
+            result: '',
+            error: `${operation} 失败: ${e.message}`,
+        };
+    }
+}
+// ===================== 工具定义 =====================
+/** 文本处理工具 */
+exports.textProcessTool = {
+    id: 'text_process',
+    name: '文本处理',
+    description: '对文本执行各种处理操作。支持：match（正则匹配）、replace（正则替换）、extract（提取邮箱/URL/电话等）、split（分割）、stats（文本统计：字数/行数/词数等）。可使用内置模板（email/url/phone_cn/ipv4/date_iso/number/chinese）或自定义正则。',
+    category: 'utility',
+    parameters: {
+        type: 'object',
+        properties: {
+            text: {
+                type: 'string',
+                description: '待处理的文本内容',
+            },
+            operation: {
+                type: 'string',
+                description: '操作类型：match（正则匹配）、replace（替换）、extract（提取）、split（分割）、stats（统计）',
+                enum: ['match', 'replace', 'extract', 'split', 'stats'],
+            },
+            pattern: {
+                type: 'string',
+                description: '正则表达式或分隔符。extract 操作时也可使用内置模板名：email/url/phone_cn/ipv4/date_iso/number/chinese',
+            },
+            replacement: {
+                type: 'string',
+                description: '替换字符串（replace 操作使用），支持 $1、$2 等捕获组引用',
+            },
+            flags: {
+                type: 'string',
+                description: '正则标志，如 g（全局）、i（忽略大小写）、m（多行）。默认 g',
+            },
+        },
+        required: ['text', 'operation'],
+    },
+    async execute(input) {
+        const text = input.text || '';
+        if (!text)
+            return { error: 'text 参数不能为空' };
+        return processText(text, input.operation, input.pattern, input.replacement, input.flags);
+    },
+};
+/** 编解码工具 */
+exports.encodeDecodeTool = {
+    id: 'encode_decode',
+    name: '编码/解码',
+    description: '对文本执行编码或解码操作。支持：Base64 编解码、URL 编解码、Unicode 转义/反转义、Hex 编解码、HTML 实体转义/反转义。',
+    category: 'utility',
+    parameters: {
+        type: 'object',
+        properties: {
+            text: {
+                type: 'string',
+                description: '待编码/解码的文本',
+            },
+            operation: {
+                type: 'string',
+                description: '编解码操作类型',
+                enum: [
+                    'base64_encode',
+                    'base64_decode',
+                    'url_encode',
+                    'url_decode',
+                    'unicode_escape',
+                    'unicode_unescape',
+                    'hex_encode',
+                    'hex_decode',
+                    'html_escape',
+                    'html_unescape',
+                ],
+            },
+        },
+        required: ['text', 'operation'],
+    },
+    async execute(input) {
+        const text = input.text || '';
+        return encodeDecode(text, input.operation);
+    },
+};
+/** Hash 计算工具 */
+exports.computeHashTool = {
+    id: 'compute_hash',
+    name: '计算 Hash',
+    description: '计算文本的哈希摘要值。支持 MD5、SHA1、SHA256、SHA512 算法。可用于数据完整性校验、签名生成等场景。可选输出 Hex 或 Base64 格式。',
+    category: 'utility',
+    parameters: {
+        type: 'object',
+        properties: {
+            text: {
+                type: 'string',
+                description: '待计算 Hash 的文本内容',
+            },
+            algorithm: {
+                type: 'string',
+                description: '哈希算法',
+                enum: ['md5', 'sha1', 'sha256', 'sha512'],
+                default: 'sha256',
+            },
+            encoding: {
+                type: 'string',
+                description: '输出编码格式：hex（默认）或 base64',
+                enum: ['hex', 'base64'],
+                default: 'hex',
+            },
+            secret: {
+                type: 'string',
+                description: '可选的密钥，提供时将计算 HMAC 而非普通 Hash',
+            },
+        },
+        required: ['text'],
+    },
+    async execute(input) {
+        const algorithm = input.algorithm || 'sha256';
+        const encoding = (input.encoding ||
+            'hex');
+        const text = input.text || '';
+        try {
+            let hash;
+            if (input.secret) {
+                hash = crypto.createHmac(algorithm, input.secret);
+            }
+            else {
+                hash = crypto.createHash(algorithm);
+            }
+            hash.update(text, 'utf-8');
+            const digest = hash.digest(encoding);
+            return {
+                algorithm: input.secret ? `hmac-${algorithm}` : algorithm,
+                encoding,
+                hash: digest,
+                inputLength: text.length,
+            };
+        }
+        catch (e) {
+            return { error: `Hash 计算失败: ${e.message}` };
+        }
+    },
+};

package/dist/tools/web-search.tool.d.ts

@@ -0,0 +1,28 @@
+import type { ToolDefinition } from '../types';
+/** 网络搜索结果 */
+interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    publishedAt?: string;
+    source?: string;
+}
+/** 网络搜索工具 */
+export declare const webSearchTool: ToolDefinition<{
+    query: string;
+    maxResults?: number;
+    timeRange?: string;
+}, {
+    query: string;
+    total: number;
+    results: SearchResult[];
+}>;
+/** 获取网页内容 */
+export declare const fetchWebPageTool: ToolDefinition<{
+    url: string;
+}, {
+    url: string;
+    title: string;
+    content: string;
+}>;
+export {};

package/dist/tools/web-search.tool.js

@@ -0,0 +1,304 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWebPageTool = exports.webSearchTool = void 0;
+/**
+ * 网络搜索工具
+ *
+ * 让 Agent 能够搜索互联网信息（预留接口，可对接各类搜索 API）。
+ *
+ * 工具说明：
+ * - web_search：搜索互联网获取最新信息、新闻、研究报告
+ * - fetch_web_page：获取指定 URL 的网页正文内容
+ *
+ * 对接方案（待实现）：
+ * - SerpAPI / Tavily / Bing Search API —— 用于 web_search
+ * - Cheerio / Puppeteer / Jina Reader API —— 用于 fetch_web_page
+ *
+ * 当前状态：返回模拟数据，接入外部 API 后替换 execute 实现。
+ */
+const axios_1 = __importDefault(require("axios"));
+/** 网络搜索工具 */
+exports.webSearchTool = {
+    id: 'web_search',
+    name: '网络搜索',
+    description: '搜索互联网获取最新信息、新闻、研究报告等。当需要实时数据或外部知识时使用此工具。',
+    category: 'search',
+    parameters: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: '搜索关键词',
+            },
+            maxResults: {
+                type: 'integer',
+                description: '最大返回结果数，默认 5，最大 20',
+                minimum: 1,
+                maximum: 20,
+                default: 5,
+            },
+            timeRange: {
+                type: 'string',
+                description: '时间范围筛选: day/week/month/year/any',
+                enum: ['day', 'week', 'month', 'year', 'any'],
+                default: 'any',
+            },
+        },
+        required: ['query'],
+    },
+    async execute(input) {
+        const provider = process.env.SEARCH_PROVIDER || 'bing';
+        const apiKey = process.env.SEARCH_API_KEY || '';
+        const query = input.query.trim();
+        const maxResults = Math.min(Math.max(Number(input.maxResults) || 5, 1), 20);
+        console.log(`[WebSearch] 搜索: "${query}" (provider=${provider}, maxResults=${maxResults})`);
+        if (!apiKey && provider !== 'searxng') {
+            console.warn(`[WebSearch] 未配置 SEARCH_API_KEY，provider=${provider} 需要 API 密钥`);
+            return {
+                query,
+                total: 0,
+                results: [],
+                hint: `搜索功能未配置。请设置环境变量 SEARCH_API_KEY 和 SEARCH_PROVIDER（可选值: tavily/serpapi/bing/searxng）。当前 provider=${provider}。`,
+            };
+        }
+        try {
+            switch (provider) {
+                case 'tavily':
+                    return await searchTavily(query, maxResults, input.timeRange, apiKey);
+                case 'serpapi':
+                    return await searchSerpApi(query, maxResults, apiKey);
+                case 'bing':
+                    return await searchBing(query, maxResults, apiKey);
+                case 'searxng':
+                    return await searchSearxng(query, maxResults, process.env.SEARCH_BASE_URL);
+                default:
+                    return {
+                        query,
+                        total: 0,
+                        results: [],
+                        hint: `未知的搜索 provider: ${provider}。支持的值: tavily, serpapi, bing, searxng。`,
+                    };
+            }
+        }
+        catch (error) {
+            const message = error?.response?.data?.message ||
+                error?.message ||
+                String(error);
+            console.error(`[WebSearch] ${provider} 搜索失败:`, message);
+            return {
+                query,
+                total: 0,
+                results: [],
+                error: `搜索失败: ${message}`,
+            };
+        }
+    },
+};
+// ===================== 搜索后端实现 =====================
+/** Tavily 搜索 —— 专为 AI Agent 设计的高质量搜索 API */
+async function searchTavily(query, maxResults, timeRange, apiKey) {
+    const response = await axios_1.default.post('https://api.tavily.com/search', {
+        query,
+        search_depth: 'advanced',
+        include_answer: false,
+        include_images: false,
+        max_results: maxResults,
+        time_range: timeRange && timeRange !== 'any' ? timeRange : undefined,
+    }, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        timeout: 30000,
+    });
+    const results = (response.data?.results || []).map((r) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.content || r.snippet || '',
+        publishedAt: r.published_date,
+        source: new URL(r.url).hostname,
+    }));
+    return { query, total: results.length, results };
+}
+/** SerpAPI —— Google 搜索结果 */
+async function searchSerpApi(query, maxResults, apiKey) {
+    const response = await axios_1.default.get('https://serpapi.com/search', {
+        params: {
+            q: query,
+            engine: 'google',
+            api_key: apiKey,
+            num: maxResults,
+        },
+        timeout: 30000,
+    });
+    const organic = response.data?.organic_results || [];
+    const results = organic
+        .slice(0, maxResults)
+        .map((r) => ({
+        title: r.title || '',
+        url: r.link || r.url || '',
+        snippet: r.snippet || '',
+        publishedAt: r.date,
+        source: new URL(r.link || r.url || 'http://example.com').hostname,
+    }));
+    return { query, total: results.length, results };
+}
+/** Bing Search API */
+async function searchBing(query, maxResults, apiKey) {
+    const response = await axios_1.default.get('https://api.bing.microsoft.com/v7.0/search', {
+        headers: { 'Ocp-Apim-Subscription-Key': apiKey },
+        params: { q: query, count: maxResults, mkt: 'zh-CN' },
+        timeout: 30000,
+    });
+    const items = response.data?.webPages?.value || [];
+    const results = items.map((r) => ({
+        title: r.name || '',
+        url: r.url || '',
+        snippet: r.snippet || '',
+        source: new URL(r.url || 'http://example.com').hostname,
+    }));
+    return { query, total: results.length, results };
+}
+/** SearXNG —— 自托管搜索聚合器（无需 API Key） */
+async function searchSearxng(query, maxResults, baseUrl) {
+    if (!baseUrl) {
+        throw new Error('使用 searxng 搜索必须配置 SEARCH_BASE_URL 环境变量');
+    }
+    const response = await axios_1.default.get(`${baseUrl.replace(/\/$/, '')}/search`, {
+        params: { q: query, format: 'json', pageno: 1 },
+        timeout: 30000,
+    });
+    const items = (response.data?.results || []).slice(0, maxResults);
+    const results = items.map((r) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.content || r.snippet || '',
+        publishedAt: r.publishedDate,
+        source: r.engine || new URL(r.url || 'http://example.com').hostname,
+    }));
+    return { query, total: results.length, results };
+}
+// ===================== 网页抓取后端实现 =====================
+/** Jina Reader —— 免费网页内容提取（无需 API Key） */
+async function fetchJinaReader(url) {
+    const response = await axios_1.default.get(`https://r.jina.ai/http://${url.replace(/^https?:\/\//, '')}`, {
+        headers: { Accept: 'text/plain' },
+        timeout: 30000,
+    });
+    const text = String(response.data || '');
+    const lines = text.split('\n').filter(Boolean);
+    const title = lines[0] || '';
+    const content = lines.slice(1).join('\n').trim();
+    return { url, title, content };
+}
+/** Firecrawl —— 高质量网页抓取服务 */
+async function fetchFirecrawl(url, apiKey) {
+    if (!apiKey) {
+        throw new Error('使用 firecrawl 抓取必须配置 FIRECRAWL_API_KEY 环境变量');
+    }
+    const response = await axios_1.default.post('https://api.firecrawl.dev/v1/scrape', { url, formats: ['markdown'] }, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        timeout: 60000,
+    });
+    const data = response.data?.data || {};
+    return {
+        url,
+        title: data.metadata?.title || '',
+        content: data.markdown || data.content || '',
+    };
+}
+/** Cheerio —— 服务器端网页解析（Node.js 环境） */
+async function fetchCheerio(url) {
+    // 动态导入 cheerio，避免未安装时的硬依赖
+    let cheerio;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require('cheerio');
+        cheerio = mod;
+    }
+    catch {
+        throw new Error('cheerio 未安装。请运行 npm install cheerio 后重试。');
+    }
+    const response = await axios_1.default.get(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.0',
+        },
+        timeout: 30000,
+    });
+    const $ = cheerio.load(response.data);
+    // 移除脚本、样式、导航等噪音元素
+    $('script, style, nav, header, footer, aside, .advertisement, .ads').remove();
+    const title = $('title').text().trim() || $('h1').first().text().trim() || '';
+    // 优先取 article 或 main，否则取 body 中的段落
+    const articleText = $('article, main').first().text();
+    const bodyText = $('body').text();
+    const content = (articleText.length > 50 ? articleText : bodyText)
+        .replace(/\s+/g, ' ')
+        .trim();
+    return { url, title, content };
+}
+/** 获取网页内容 */
+exports.fetchWebPageTool = {
+    id: 'fetch_web_page',
+    name: '获取网页内容',
+    description: '获取指定 URL 的网页正文内容。用于深入阅读搜索结果中的某篇文章。',
+    category: 'search',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: '网页 URL 地址',
+            },
+        },
+        required: ['url'],
+    },
+    async execute(input) {
+        const url = input.url.trim();
+        const provider = process.env.WEB_FETCH_PROVIDER || 'jina';
+        console.log(`[FetchWebPage] 获取: ${url} (provider=${provider})`);
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return {
+                url,
+                title: '',
+                content: '',
+                error: '无效的 URL，必须以 http:// 或 https:// 开头',
+            };
+        }
+        try {
+            switch (provider) {
+                case 'jina':
+                    return await fetchJinaReader(url);
+                case 'firecrawl':
+                    return await fetchFirecrawl(url, process.env.FIRECRAWL_API_KEY || '');
+                case 'cheerio':
+                    return await fetchCheerio(url);
+                default:
+                    return {
+                        url,
+                        title: '',
+                        content: '',
+                        hint: `未知的抓取 provider: ${provider}。支持的值: jina, firecrawl, cheerio。`,
+                    };
+            }
+        }
+        catch (error) {
+            const message = error?.response?.data?.message ||
+                error?.message ||
+                String(error);
+            console.error('[FetchWebPage] 抓取失败:', message);
+            return {
+                url,
+                title: '',
+                content: '',
+                error: `网页抓取失败: ${message}`,
+            };
+        }
+    },
+};