@myassis/gateway 1.0.0

package/dist/services/tools/keyboard.js

@@ -0,0 +1,145 @@
+import { keyboard, Key } from '@nut-tree/nut-js';
+// 可打印 ASCII 字符范围（空格到 ~）
+const PRINTABLE_ASCII_START = 32;
+const PRINTABLE_ASCII_END = 126;
+// 校验文本中的所有字符是否都是键盘可输入的字符
+function validateText(text) {
+    for (let i = 0; i < text.length; i++) {
+        const charCode = text.charCodeAt(i);
+        // 检查是否在可打印 ASCII 范围内
+        if (charCode < PRINTABLE_ASCII_START || charCode > PRINTABLE_ASCII_END) {
+            return { valid: false, invalidChar: text[i], charCode };
+        }
+    }
+    return { valid: true };
+}
+// 按键名称到 nut-js Key 的映射
+const keyMap = {
+    // 常用键
+    enter: Key.Enter,
+    return: Key.Enter,
+    escape: Key.Escape,
+    esc: Key.Escape,
+    tab: Key.Tab,
+    space: Key.Space,
+    backspace: Key.Backspace,
+    delete: Key.Delete,
+    del: Key.Delete,
+    // 方向键
+    up: Key.Up,
+    down: Key.Down,
+    left: Key.Left,
+    right: Key.Right,
+    // 功能键
+    f1: Key.F1,
+    f2: Key.F2,
+    f3: Key.F3,
+    f4: Key.F4,
+    f5: Key.F5,
+    f6: Key.F6,
+    f7: Key.F7,
+    f8: Key.F8,
+    f9: Key.F9,
+    f10: Key.F10,
+    f11: Key.F11,
+    f12: Key.F12,
+    // 修饰键
+    ctrl: Key.LeftControl,
+    control: Key.LeftControl,
+    alt: Key.LeftAlt,
+    shift: Key.LeftShift,
+    meta: Key.LeftSuper,
+    win: Key.LeftSuper,
+    cmd: Key.LeftSuper,
+    command: Key.LeftSuper,
+};
+// 解析组合键，如 "Ctrl+C" 或 "Alt+Shift+F4"
+function parseHotkey(keysStr) {
+    const parts = keysStr.split(/[+\-]/).map(s => s.trim().toLowerCase());
+    const keys = [];
+    for (const part of parts) {
+        const mappedKey = keyMap[part];
+        if (mappedKey) {
+            keys.push(mappedKey);
+        }
+        else {
+            // 处理单个字符
+            if (part.length === 1) {
+                keys.push(part);
+            }
+        }
+    }
+    return keys;
+}
+// 解析单个按键
+function parseKey(keyStr) {
+    const lowerKey = keyStr.toLowerCase();
+    if (keyMap[lowerKey]) {
+        return keyMap[lowerKey];
+    }
+    // 单个字符直接返回
+    if (keyStr.length === 1) {
+        return keyStr;
+    }
+    throw new Error(`未知按键: ${keyStr}`);
+}
+export const keyboardTool = {
+    name: 'keyboard',
+    description: '控制键盘输入和按键操作',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '操作类型：type（输入文本）、press（按压键）、hotkey（组合键）',
+                enum: ['type', 'press', 'hotkey'],
+            },
+            text: { type: 'string', description: '要输入的文本（type 必填）' },
+            key: { type: 'string', description: '按键名称（press 必填），如 Enter、Escape、Tab' },
+            keys: {
+                type: 'string',
+                description: '组合键，如 Ctrl+C、Alt+F4（hotkey 必填）',
+            },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, text, key, keys } = args;
+            switch (action) {
+                case 'type':
+                    if (typeof text !== 'string') {
+                        return { success: false, errorMessage: 'type 操作需要 text 参数' };
+                    }
+                    const validation = validateText(text);
+                    if (!validation.valid) {
+                        return { success: false, errorMessage: `文本包含不可输入字符: "${validation.invalidChar}" (字符码: ${validation.charCode})` };
+                    }
+                    await keyboard.type(text);
+                    return { success: true, output: `已输入文本: "${text}"` };
+                case 'press':
+                    if (typeof key !== 'string') {
+                        return { success: false, errorMessage: 'press 操作需要 key 参数' };
+                    }
+                    const parsedKey = parseKey(key);
+                    await keyboard.pressKey(parsedKey);
+                    return { success: true, output: `已按下按键: ${key}` };
+                case 'hotkey':
+                    if (typeof keys !== 'string') {
+                        return { success: false, errorMessage: 'hotkey 操作需要 keys 参数' };
+                    }
+                    const hotkeys = parseHotkey(keys);
+                    if (hotkeys.length === 0) {
+                        return { success: false, errorMessage: '无法解析组合键' };
+                    }
+                    await keyboard.pressKey(...hotkeys);
+                    return { success: true, output: `已执行组合键: ${keys}` };
+                default:
+                    return { success: false, errorMessage: `未知的键盘操作: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, errorMessage: `键盘操作失败: ${error?.message || error}` };
+        }
+    },
+};

package/dist/services/tools/model.js

@@ -0,0 +1,86 @@
+import { modelsService } from '../dataService';
+export const modelTool = {
+    name: 'model',
+    description: '模型管理工具',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '操作类型：list、add、update、delete、setPrimary',
+                enum: ['list', 'add', 'update', 'delete', 'setPrimary'],
+            },
+            modelId: { type: 'string', description: '模型 ID（update/delete/setPrimary）' },
+            modelName: { type: 'string', description: '模型名称（add/update）' },
+            modelIdName: { type: 'string', description: '模型 ID 名称（add）' },
+            baseUrl: { type: 'string', description: 'API 地址（add/update）' },
+            apiKey: { type: 'string', description: 'API Key（add）' },
+            provider: { type: 'string', description: '提供商', default: 'doubao' },
+            isPrimary: { type: 'boolean', description: '设为默认', default: false },
+            supportsToolCall: { type: 'boolean', description: '支持工具调用', default: true },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, modelId, modelName, modelIdName, baseUrl, apiKey, provider = 'doubao', isPrimary = false, supportsToolCall = true } = args;
+            switch (action) {
+                case 'list': {
+                    const response = await modelsService.list();
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '获取列表失败' };
+                    const models = response.data || [];
+                    return { success: true, output: JSON.stringify({ total: models.length, models: models.map((m) => ({ id: m.id, name: m.modelName, provider: m.provider, baseUrl: m.baseUrl, isPrimary: m.isPrimary, supportsToolCall: m.supportsToolCall })) }) };
+                }
+                case 'add': {
+                    if (!modelName || !baseUrl || !modelIdName)
+                        return { success: false, errorMessage: '添加模型需要提供模型名称、模型 ID 和 API 地址' };
+                    const response = await modelsService.create({ modelName, modelId: modelIdName, baseUrl, apiKey, provider, isPrimary, supportsToolCall });
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '添加失败' };
+                    return { success: true, output: JSON.stringify({ model: response.data }) };
+                }
+                case 'update': {
+                    if (!modelId)
+                        return { success: false, errorMessage: '修改模型需要提供模型 ID' };
+                    const updateData = {};
+                    if (modelName !== undefined)
+                        updateData.modelName = modelName;
+                    if (baseUrl !== undefined)
+                        updateData.baseUrl = baseUrl;
+                    if (provider !== undefined)
+                        updateData.provider = provider;
+                    if (isPrimary !== undefined)
+                        updateData.isPrimary = isPrimary;
+                    if (supportsToolCall !== undefined)
+                        updateData.supportsToolCall = supportsToolCall;
+                    const response = await modelsService.update(modelId, updateData);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '更新失败' };
+                    return { success: true, output: JSON.stringify({ model: response.data }) };
+                }
+                case 'delete': {
+                    if (!modelId)
+                        return { success: false, errorMessage: '删除模型需要提供模型 ID' };
+                    const response = await modelsService.delete(modelId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '删除失败' };
+                    return { success: true };
+                }
+                case 'setPrimary': {
+                    if (!modelId)
+                        return { success: false, errorMessage: '设为默认需要提供模型 ID' };
+                    const response = await modelsService.setPrimary(modelId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '设置失败' };
+                    return { success: true };
+                }
+                default:
+                    return { success: false, errorMessage: `未知的模型操作: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, errorMessage: `模型操作失败: ${error?.message}` };
+        }
+    },
+};

package/dist/services/tools/mouse.js

@@ -0,0 +1,55 @@
+import { mouse, Button } from '@nut-tree/nut-js';
+export const mouseTool = {
+    name: 'mouse',
+    description: '控制鼠标移动、点击和滚轮操作',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '鼠标操作类型：move、click、rightClick、doubleClick、scroll、position',
+            },
+            x: { type: 'number', description: '目标 X 坐标（move 必填）' },
+            y: { type: 'number', description: '目标 Y 坐标（move 必填）' },
+            button: { type: 'string', description: '鼠标按钮：left、right、middle，默认 left', default: 'left' },
+            scrollX: { type: 'number', description: '水平滚动量', default: 0 },
+            scrollY: { type: 'number', description: '垂直滚动量', default: 0 },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, x, y, button = 'left', scrollX = 0, scrollY = 0 } = args;
+            switch (action) {
+                case 'move':
+                    if (typeof x !== 'number' || typeof y !== 'number') {
+                        return { success: false, errorMessage: 'move 操作需要 x 和 y 坐标' };
+                    }
+                    await mouse.setPosition({ x, y });
+                    return { success: true, output: `鼠标移动到 (${x}, ${y})` };
+                case 'click':
+                case 'rightClick':
+                case 'doubleClick':
+                    if (action === 'doubleClick') {
+                        await mouse.click(Button.LEFT);
+                        await new Promise(r => setTimeout(r, 100));
+                    }
+                    const btn = button === 'right' ? Button.RIGHT : button === 'middle' ? Button.MIDDLE : Button.LEFT;
+                    await mouse.click(btn);
+                    return { success: true, output: `${button} 键${action === 'doubleClick' ? '双' : ''}击成功` };
+                case 'scroll':
+                    await mouse.scrollDown(scrollY);
+                    await mouse.scrollRight(scrollX);
+                    return { success: true, output: `滚动 (${scrollX}, ${scrollY})` };
+                case 'position':
+                    const pos = await mouse.getPosition();
+                    return { success: true, output: `当前鼠标位置 (${pos.x}, ${pos.y})` };
+                default:
+                    return { success: false, errorMessage: `未知的鼠标操作: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, errorMessage: `鼠标操作失败: ${error?.message || error}` };
+        }
+    },
+};

package/dist/services/tools/screenshot.js

@@ -0,0 +1,19 @@
+import screenshot from 'screenshot-desktop';
+export const screenshotTool = {
+    name: 'screenshot',
+    description: '截取当前电脑屏幕的截图，这个操作属于危险操作，没有用户的主动允许禁止使用',
+    parameters: { type: 'object', properties: {}, required: [] },
+    handler: async () => {
+        try {
+            const imgBuffer = await screenshot({ format: 'jpeg', quality: 20 });
+            const base64 = imgBuffer.toString('base64');
+            return {
+                success: true,
+                output: JSON.stringify({ image: `data:image/jpeg;base64,${base64}`, size: imgBuffer.length }),
+            };
+        }
+        catch (error) {
+            return { success: false, errorMessage: `截图失败: ${error?.message || error}` };
+        }
+    },
+};

package/dist/services/tools/search.js

@@ -0,0 +1,53 @@
+import got from 'got';
+import * as cheerio from 'cheerio';
+export const searchTool = {
+    name: 'search',
+    description: '执行网络搜索',
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: '搜索关键词' },
+            limit: { type: 'number', description: '返回结果数量上限', default: 5 },
+        },
+        required: ['query'],
+    },
+    handler: async (args) => {
+        try {
+            const { query, limit = 5 } = args;
+            const response = await got(`https://cn.bing.com/search?q=${encodeURIComponent(query)}`, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    'Accept-Language': 'zh-CN,zh;q=0.9',
+                },
+                timeout: { request: 10000 },
+            });
+            const $ = cheerio.load(response.body);
+            const results = [];
+            $('li.b_algo').each((_, el) => {
+                if (results.length >= limit)
+                    return false;
+                const titleEl = $(el).find('h2 a');
+                const title = titleEl.text().trim();
+                const url = titleEl.attr('href') || '';
+                const snippet = $(el).find('div.b_caption p').text().trim();
+                if (title)
+                    results.push({ title, url, snippet });
+            });
+            if (results.length === 0) {
+                $('div.b_listnav_bing').find('li').each((_, el) => {
+                    if (results.length >= limit)
+                        return false;
+                    const titleEl = $(el).find('a');
+                    const title = titleEl.text().trim();
+                    const url = titleEl.attr('href') || '';
+                    if (title && url)
+                        results.push({ title, url, snippet: '' });
+                });
+            }
+            return { success: true, output: JSON.stringify({ query, total: results.length, results }) };
+        }
+        catch (error) {
+            return { success: false, errorMessage: `搜索失败: ${error.message}` };
+        }
+    },
+};

package/dist/services/tools/skill.js

@@ -0,0 +1,108 @@
+import { skillsService, skillHubService } from '../dataService';
+import { persistStore } from '@/stores';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('skill');
+export const skillTool = {
+    name: 'skill',
+    description: '技能管理工具',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '操作类型：listInstalled、search、install、uninstall、setApiKey、rate、detail、getApiKey',
+                enum: ['listInstalled', 'search', 'install', 'uninstall', 'setApiKey', 'rate', 'detail', 'getApiKey'],
+            },
+            query: { type: 'string', description: '搜索关键词' },
+            skillId: { type: 'string', description: '技能 ID（uninstall/detail/setApiKey/getApiKey）' },
+            hubId: { type: 'string', description: '技能市场 ID（search/rate）' },
+            apiKey: { type: 'string', description: 'API Key（setApiKey）' },
+            apiBaseUrl: { type: 'string', description: 'API 地址（setApiKey）' },
+            rating: { type: 'number', description: '评分 1-5（rate）' },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, query, skillId, hubId, apiKey, apiBaseUrl, rating } = args;
+            switch (action) {
+                case 'listInstalled': {
+                    const response = await skillsService.list();
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '获取列表失败' };
+                    const skills = response.data || [];
+                    return { success: true, output: JSON.stringify({ total: skills.length, skills: skills.map((s) => ({ id: s.id, name: s.name, description: s.description, version: s.version, status: s.status })) }) };
+                }
+                case 'search': {
+                    const response = await skillHubService.list({ keyword: query, pageSize: 10 });
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '搜索失败' };
+                    const skills = response.data?.items || response.data || [];
+                    return { success: true, output: JSON.stringify({ query, total: skills.length, skills: skills.map((s) => ({ id: s.id, hubId: s.hubId, name: s.name, description: s.description, author: s.author, tags: s.tags, rating: s.rating })) }) };
+                }
+                case 'install': {
+                    const installId = hubId || query;
+                    if (!installId)
+                        return { success: false, errorMessage: '安装需要提供 hubId 或 query' };
+                    const response = await skillsService.install(installId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '安装失败' };
+                    return { success: true };
+                }
+                case 'uninstall': {
+                    if (!skillId)
+                        return { success: false, errorMessage: '卸载需要提供技能 ID' };
+                    const response = await skillsService.uninstall(skillId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '卸载失败' };
+                    return { success: true };
+                }
+                case 'detail': {
+                    if (!skillId)
+                        return { success: false, errorMessage: '查看详情需要提供技能 ID' };
+                    const response = await skillsService.get(skillId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '获取详情失败' };
+                    // 表明该技能已被使用
+                    const detailHubId = response.data?.templateId;
+                    if (detailHubId) {
+                        skillHubService.use(detailHubId).catch((err) => logger.warn('技能使用记录失败:', err?.message));
+                    }
+                    const apikey = await skillsService.getApiKey(skillId);
+                    return { success: true, output: JSON.stringify({ skill: { ...response.data, apiKey: apikey.apiKey } }) };
+                }
+                case 'setApiKey': {
+                    if (!skillId || !apiKey)
+                        return { success: false, errorMessage: '设置 API Key 需要提供技能 ID 和 API Key' };
+                    const response = await skillsService.setApiKey(skillId, apiKey);
+                    if (!response)
+                        return { success: false, errorMessage: '设置失败' };
+                    return { success: true };
+                }
+                case 'rate': {
+                    if (!hubId || rating === undefined)
+                        return { success: false, errorMessage: '评分需要提供 hubId 和评分（1-5）' };
+                    if (rating < 1 || rating > 5)
+                        return { success: false, errorMessage: '评分必须是 1-5 之间的整数' };
+                    const response = await skillHubService.rate(hubId, rating);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '评分失败' };
+                    return { success: true };
+                }
+                case 'getApiKey': {
+                    if (!skillId)
+                        return { success: false, errorMessage: '获取 API Key 需要提供技能 ID' };
+                    const apikey = persistStore.getSkillApiKey(skillId);
+                    if (apikey)
+                        return { success: true, output: JSON.stringify({ apiKey: apikey.apiKey }) };
+                    return { success: false, errorMessage: '未找到 API Key' };
+                }
+                default:
+                    return { success: false, errorMessage: `未知的技能操作: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, errorMessage: `技能操作失败: ${error?.message}` };
+        }
+    },
+};

package/dist/services/tools/task.js

@@ -0,0 +1,110 @@
+import { tasksService } from '../dataService';
+import { authStore } from '@/stores';
+import { validPlatformApplies, getPlatform } from '@pocketclaw/shared/dist/utils/system.js';
+export const taskTool = {
+    name: 'task',
+    description: '任务管理工具',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: '操作类型：create、list、update、delete',
+                enum: ['create', 'list', 'update', 'delete'],
+            },
+            title: { type: 'string', description: '任务标题（create）' },
+            description: { type: 'string', description: '任务描述（create/update）' },
+            taskType: { type: 'string', description: '任务类型：one_time、recurring', enum: ['one_time', 'recurring'], default: 'one_time' },
+            recurrenceRule: { type: 'string', description: '重复规则', enum: ['daily', 'weekly', 'monthly', 'trading_day', 'work_day', 'interval'] },
+            intervalValue: { type: 'number', description: '间隔值（interval）' },
+            intervalUnit: { type: 'string', description: '间隔单位', enum: ['minutes', 'hours', 'days'] },
+            startTime: { type: 'string', description: '开始时间' },
+            endTime: { type: 'string', description: '结束时间' },
+            scheduledAt: { type: 'string', description: '计划执行时间' },
+            platformApply: { type: 'string', description: '适用平台', enum: validPlatformApplies, default: getPlatform() },
+            status: { type: 'string', description: '任务状态筛选', enum: ['pending', 'doing', 'done', 'cancelled'] },
+            taskId: { type: 'string', description: '任务 ID（update/delete）' },
+            newTitle: { type: 'string', description: '新标题（update）' },
+            newDescription: { type: 'string', description: '新描述（update）' },
+            newStatus: { type: 'string', description: '新状态（update）', enum: ['pending', 'doing', 'done', 'cancelled'] },
+            newRecurrenceRule: { type: 'string', description: '新重复规则（update）' },
+            newScheduledAt: { type: 'string', description: '新计划执行时间（update）' },
+        },
+        required: ['action'],
+    },
+    handler: async (args) => {
+        try {
+            const { action, title, description, taskType, recurrenceRule, intervalValue, intervalUnit, startTime, endTime, scheduledAt, platformApply, status, taskId, newTitle, newDescription, newStatus, newRecurrenceRule, newScheduledAt } = args;
+            switch (action) {
+                case 'create': {
+                    if (!title)
+                        return { success: false, errorMessage: '创建任务需要提供标题（title）' };
+                    const createData = { title, taskType: taskType || 'one_time' };
+                    if (description)
+                        createData.description = description;
+                    if (recurrenceRule)
+                        createData.recurrenceRule = recurrenceRule;
+                    if (intervalValue !== undefined)
+                        createData.intervalValue = intervalValue;
+                    if (intervalUnit)
+                        createData.intervalUnit = intervalUnit;
+                    if (startTime)
+                        createData.startTime = startTime;
+                    if (endTime)
+                        createData.endTime = endTime;
+                    if (scheduledAt)
+                        createData.scheduledAt = scheduledAt;
+                    const userId = authStore.getUserId();
+                    if (!userId) {
+                        return { success: false, errorMessage: '未登录' };
+                    }
+                    createData.platformApply = platformApply || getPlatform();
+                    const response = await tasksService.create(createData, String(userId));
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '创建任务失败' };
+                    return { success: true, output: JSON.stringify({ task: response.data }) };
+                }
+                case 'list': {
+                    const response = await tasksService.list({ status });
+                    if (!response.success)
+                        return { success: false, errorMessage: '获取任务列表失败' };
+                    const tasks = response.data || [];
+                    const stats = { total: tasks.length, pending: tasks.filter((t) => t.status === 'pending').length, doing: tasks.filter((t) => t.status === 'doing').length, done: tasks.filter((t) => t.status === 'done').length, cancelled: tasks.filter((t) => t.status === 'cancelled').length };
+                    return { success: true, output: JSON.stringify({ stats, total: tasks.length, tasks: tasks.map((t) => ({ id: t.id, title: t.title, taskType: t.taskType, recurrenceRule: t.recurrenceRule, scheduledAt: t.scheduledAt, status: t.status })) }) };
+                }
+                case 'update': {
+                    if (!taskId)
+                        return { success: false, errorMessage: '修改任务需要提供任务 ID（taskId）' };
+                    const updateData = {};
+                    if (newTitle !== undefined)
+                        updateData.title = newTitle;
+                    if (newDescription !== undefined)
+                        updateData.description = newDescription;
+                    if (newStatus !== undefined)
+                        updateData.status = newStatus;
+                    if (newRecurrenceRule !== undefined)
+                        updateData.recurrenceRule = newRecurrenceRule;
+                    if (newScheduledAt !== undefined)
+                        updateData.scheduledAt = newScheduledAt;
+                    const response = await tasksService.update(taskId, updateData);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '更新任务失败' };
+                    return { success: true };
+                }
+                case 'delete': {
+                    if (!taskId)
+                        return { success: false, errorMessage: '删除任务需要提供任务 ID（taskId）' };
+                    const response = await tasksService.delete(taskId);
+                    if (!response.success)
+                        return { success: false, errorMessage: response.error || '删除任务失败' };
+                    return { success: true };
+                }
+                default:
+                    return { success: false, errorMessage: `未知的任务操作: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, errorMessage: `任务操作失败: ${error?.message}` };
+        }
+    },
+};

package/dist/services/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/tools/webFetch.js

@@ -0,0 +1,34 @@
+import got from 'got';
+import * as cheerio from 'cheerio';
+export const webFetchTool = {
+    name: 'webFetch',
+    description: '获取网页内容，支持 JavaScript 渲染',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: '目标网页 URL' },
+            query: { type: 'string', description: '要提取的内容选择器（CSS 选择器）' },
+        },
+        required: ['url'],
+    },
+    handler: async (args) => {
+        try {
+            const { url, query } = args;
+            const response = await got(url, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                },
+                timeout: { request: 15000 },
+            });
+            const $ = cheerio.load(response.body);
+            let content = $.html();
+            if (query) {
+                content = $(query).text().trim() || `选择器 ${query} 未找到匹配内容`;
+            }
+            return { success: true, output: content.substring(0, 50000) };
+        }
+        catch (error) {
+            return { success: false, errorMessage: `网页抓取失败: ${error.message}` };
+        }
+    },
+};