完善了agent

agent/tools/calendar/calendar_info.js

@@ -0,0 +1,42 @@
+import { tool } from "langchain"
+import lunar from "lunar-javascript"
+const { Solar, Lunar, HolidayUtil, TermUtil } = lunar
+import { getAccurateTime } from "./utils.js"
+
+/**
+ * 日历工具
+ * 提供准确时间、农历信息、节气、节日和老黄历等信息
+ */
+export const getCalendarInfoTool = tool(
+  async () => {
+    try {
+      // 获取准确时间
+      const timeInfo = await getAccurateTime()
+      
+      // 获取农历信息
+      const date = new Date(timeInfo.timestamp)
+      const solar = Solar.fromDate(date)
+      const lunar = solar.getLunar()
+      
+      // 组合返回结果
+      const result = {
+        time: timeInfo,
+        weekday: solar.getWeek(),
+        lunar: { 
+          lunar: lunar.toString(), 
+          solar: solar.toString(),
+          
+        }
+      }
+      
+      return JSON.stringify(result, null, 2)
+    } catch (error) {
+      console.error('Error in calendar tool:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_calendar_info",
+    description: "获取当前准确日期时间，以及对应的农历日期"
+  }
+)

agent/tools/calendar/lunar_calendar_info.js

@@ -0,0 +1,53 @@
+import { tool } from "langchain"
+
+/**
+ * 特定日期日历工具
+ * 提供指定日期的日历信息
+ */
+export const getLunarCalendarInfoTool = tool(
+  async ({ year, month, day }) => {
+    try {
+      const date = new Date(year, month - 1, day)
+      
+      if (isNaN(date.getTime())) {
+        return JSON.stringify({ error: '无效的日期' }, null, 2)
+      }
+      
+      // 获取农历信息
+      const lunarInfo = {}
+      
+      return JSON.stringify(lunarInfo, null, 2)
+    } catch (error) {
+      console.error('Error in date calendar tool:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_lunar_calendar_info",
+    description: "获取指定日期的日历信息，包括农历信息、老黄历、当年生肖、今日宜忌、喜神方位、财神方位、今日节气、今日节日等",
+    schema: {
+      type: "object",
+      properties: {
+        year: {
+          type: "number",
+          description: "年份",
+          minimum: 1900,
+          maximum: 2100
+        },
+        month: {
+          type: "number",
+          description: "月份",
+          minimum: 1,
+          maximum: 12
+        },
+        day: {
+          type: "number",
+          description: "日期",
+          minimum: 1,
+          maximum: 31
+        }
+      },
+      required: ["year", "month", "day"]
+    }
+  }
+)

agent/tools/calendar/utils.js

@@ -0,0 +1,86 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import lunar from "lunar-javascript"
+const { Solar, Lunar, HolidayUtil, TermUtil } = lunar
+
+/**
+ * 获取准确时间工具
+ * 通过国内权威时间源获取当前准确时间
+ * @returns {string} - 返回当前准确时间的JSON字符串
+ */
+export async function getAccurateTime() {
+  const timeSources = [
+    {
+      name: 'timeapi.io',
+      url: 'https://timeapi.io/api/Time/current/zone?timeZone=Asia/Shanghai',
+      method: 'json'
+    },
+    {
+      name: '国家授时中心',
+      url: 'http://www.ntsc.ac.cn',
+      method: 'header'
+    },
+    {
+      name: '阿里云',
+      url: 'https://www.aliyun.com',
+      method: 'header'
+    },
+    {
+      name: '腾讯云',
+      url: 'https://cloud.tencent.com',
+      method: 'header'
+    },
+    {
+      name: '华为云',
+      url: 'https://www.huaweicloud.com',
+      method: 'header'
+    }
+  ]
+
+  for (const source of timeSources) {
+    try {
+      const startTime = Date.now()
+      const res = await fetch(source.url)
+      const latency = Date.now() - startTime
+
+      let timestamp = null
+      let beijingTime = null
+
+      if (source.method === 'json') {
+        const data = await res.json()
+        timestamp = new Date(data.dateTime).getTime()
+        beijingTime = data.dateTime
+      } else if (source.method === 'header') {
+        const dateHeader = res.headers.get('Date')
+        if (dateHeader) {
+          timestamp = new Date(dateHeader).getTime()
+          beijingTime = new Date(timestamp).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+        }
+      }
+
+      if (timestamp) {
+        return {
+          timestamp,
+          date: new Date(timestamp).toISOString(),
+          localTime: beijingTime,
+          source: source.name,
+          latency: latency,
+          success: true
+        }
+      }
+    } catch (error) {
+      console.log(`从 ${source.name} 获取时间失败: ${error.message}`)
+      continue
+    }
+  }
+
+  const date = new Date()
+  return {
+    timestamp: date.getTime(),
+    date: date.toISOString(),
+    localTime: date.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }),
+    success: false,
+    message: '使用本地时间作为备份'
+  }
+}
+

agent/tools/calendar/year_holidays.js

@@ -0,0 +1,41 @@
+import { tool } from "langchain"
+
+/**
+ * 年份节日列表工具
+ * 查询给定年份节日所在日期列表
+ */
+export const getYearHolidaysTool = tool(
+  async ({ year }) => {
+    try {
+      // 简化实现，返回基本节日信息
+      const holidays = [
+        { date: `${year}-01-01`, name: '元旦' },
+        { date: `${year}-02-14`, name: '情人节' },
+        { date: `${year}-05-01`, name: '劳动节' },
+        { date: `${year}-06-01`, name: '儿童节' },
+        { date: `${year}-10-01`, name: '国庆节' }
+      ]
+      
+      return JSON.stringify({ year, holidays }, null, 2)
+    } catch (error) {
+      console.error('Error in year holidays tool:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_year_holidays",
+    description: "查询给定年份节日所在日期列表",
+    schema: {
+      type: "object",
+      properties: {
+        year: {
+          type: "number",
+          description: "年份",
+          minimum: 1900,
+          maximum: 2100
+        }
+      },
+      required: ["year"]
+    }
+  }
+)

agent/tools/calendar/year_terms.js

@@ -0,0 +1,60 @@
+import { tool } from "langchain"
+
+/**
+ * 年份节气列表工具
+ * 查询给定年份节气所在日期列表
+ */
+export const getYearTermsTool = tool(
+  async ({ year }) => {
+    try {
+      // 简化实现，返回24节气信息
+      const terms = [
+        { date: `${year}-02-04`, name: '立春' },
+        { date: `${year}-02-19`, name: '雨水' },
+        { date: `${year}-03-05`, name: '惊蛰' },
+        { date: `${year}-03-20`, name: '春分' },
+        { date: `${year}-04-04`, name: '清明' },
+        { date: `${year}-04-19`, name: '谷雨' },
+        { date: `${year}-05-05`, name: '立夏' },
+        { date: `${year}-05-20`, name: '小满' },
+        { date: `${year}-06-05`, name: '芒种' },
+        { date: `${year}-06-21`, name: '夏至' },
+        { date: `${year}-07-07`, name: '小暑' },
+        { date: `${year}-07-22`, name: '大暑' },
+        { date: `${year}-08-07`, name: '立秋' },
+        { date: `${year}-08-23`, name: '处暑' },
+        { date: `${year}-09-07`, name: '白露' },
+        { date: `${year}-09-23`, name: '秋分' },
+        { date: `${year}-10-08`, name: '寒露' },
+        { date: `${year}-10-23`, name: '霜降' },
+        { date: `${year}-11-07`, name: '立冬' },
+        { date: `${year}-11-22`, name: '小雪' },
+        { date: `${year}-12-07`, name: '大雪' },
+        { date: `${year}-12-21`, name: '冬至' },
+        { date: `${year + 1}-01-05`, name: '小寒' },
+        { date: `${year + 1}-01-20`, name: '大寒' }
+      ]
+      
+      return JSON.stringify({ year, terms }, null, 2)
+    } catch (error) {
+      console.error('Error in year terms tool:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_year_terms",
+    description: "查询给定年份节气所在日期列表",
+    schema: {
+      type: "object",
+      properties: {
+        year: {
+          type: "number",
+          description: "年份",
+          minimum: 1900,
+          maximum: 2100
+        }
+      },
+      required: ["year"]
+    }
+  }
+)

agent/tools/geo/latlon.js

@@ -0,0 +1,40 @@
+import * as z from "zod"
+import { tool } from "langchain"
+
+/**
+ * 获取城市经纬度工具
+ * @param {string} city - 城市名称
+ * @returns {Object|null} - 返回经纬度对象 {lat, lng}，如果未找到则返回null
+ */
+export const getLatLngTool = tool(
+  async (input) => {
+    const { city } = input
+    try {
+      // 使用open-meteo地理编码API获取经纬度
+      console.log('获取城市经纬度:', city)
+      const url = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&language=zh&count=1`
+      const res = await fetch(url)
+      const data = await res.json()
+      
+      if (data.results?.length) {
+        return {
+          lat: data.results[0].latitude,
+          lng: data.results[0].longitude
+        }
+      }
+      
+      // 如果没有找到结果，返回null
+      return null
+    } catch (error) {
+      console.error('地理编码API调用失败:', error)
+      return null
+    }
+  },
+  {
+    name: "get_lat_lng",
+    description: `根据城市名称获取经纬度信息`,
+    schema: z.object({
+      city: z.string().describe("城市名称，例如：北京市海淀区")
+    })
+  }
+)

agent/tools/index.js

@@ -0,0 +1,20 @@
+// Tool 模块统一导出入口
+// 提供工具基类、注册表和所有工具类的统一导出
+
+// Web工具 (LangChain format)
+export { webFetchTool } from './web/fetch.js';
+export { webSearchTool } from './web/search.js';
+export { httpGetTool } from './web/http_get.js';
+export { httpPostTool } from './web/http_post.js';
+
+// 日历工具 (LangChain format)
+export { getCalendarInfoTool } from './calendar/calendar_info.js';
+export { getLunarCalendarInfoTool } from './calendar/lunar_calendar_info.js';
+export { getYearHolidaysTool } from './calendar/year_holidays.js';
+export { getYearTermsTool } from './calendar/year_terms.js';
+
+// 地理工具 (LangChain format)
+export { getLatLngTool } from './geo/latlon.js';
+
+export { getEnvTool } from './system/envs.js';
+

agent/tools/system/envs.js

@@ -0,0 +1,82 @@
+// LangChain 环境变量工具
+
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+/**
+ * 获取环境变量工具
+ * @param {Object} input - 输入参数
+ * @param {string} [input.name] - 环境变量名，不指定则返回所有
+ * @returns {string} - 返回环境变量值或所有环境变量的JSON字符串
+ */
+export const getEnvTool = tool(
+  async (input) => {
+    const { name } = input || {};
+
+    if (name) {
+      const value = process.env[name];
+      if (value === undefined) {
+        return JSON.stringify({ error: `Environment variable '${name}' not found` });
+      }
+      return JSON.stringify({ name, value });
+    }
+
+    // 返回所有环境变量（过滤敏感信息）
+    const env = { ...process.env };
+    const sensitiveKeys = ['API_KEY', 'SECRET', 'PASSWORD', 'TOKEN', 'CREDENTIAL'];
+    
+    for (const key of Object.keys(env)) {
+      const upperKey = key.toUpperCase();
+      if (sensitiveKeys.some(s => upperKey.includes(s))) {
+        env[key] = '***REDACTED***';
+      }
+    }
+
+    return JSON.stringify({ env });
+  },
+  {
+    name: 'env_get',
+    description: '获取环境变量的值。如果不指定变量名，则返回所有环境变量。',
+    schema: z.object({
+      name: z.string().optional().describe('环境变量名，不指定则返回所有')
+    })
+  }
+);
+
+/**
+ * 设置环境变量工具
+ * @param {Object} input - 输入参数
+ * @param {string} input.name - 环境变量名
+ * @param {string} input.value - 环境变量值
+ * @returns {string} - 返回设置结果的JSON字符串
+ */
+export const setEnvTool = tool(
+  async (input) => {
+    const { name, value } = input || {};
+
+    if (!name) {
+      return JSON.stringify({ error: 'Environment variable name is required' });
+    }
+
+    if (value === undefined) {
+      return JSON.stringify({ error: 'Environment variable value is required' });
+    }
+
+    try {
+      process.env[name] = value;
+      return JSON.stringify({ success: true, name, value });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to set environment variable: ${error.message}` });
+    }
+  },
+  {
+    name: 'env_set',
+    description: '设置环境变量的值。',
+    schema: z.object({
+      name: z.string().describe('环境变量名'),
+      value: z.string().describe('环境变量值')
+    })
+  }
+);
+
+export default getEnvTool;

agent/tools/system/fs_info.js

@@ -0,0 +1,257 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取系统文件信息工具
+ * @returns {string} - 返回系统文件信息的 JSON 字符串，包括分区信息和各分区剩余空间
+ */
+export const getSystemFileInfoTool = tool(
+  async (input) => {
+    try {
+      const fileSystemInfo = {
+        platform: os.platform(),
+        partitions: [],
+        volumeInfo: [],
+        diskHealth: [],
+        inodeInfo: []
+      }
+
+      // 获取文件系统信息（Windows）
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_LogicalDisk | Select-Object DeviceID,Description,FileSystem,Size,FreeSpace,VolumeName | ConvertTo-Json"')
+          const partitionData = JSON.parse(stdout)
+          const partitionsArray = Array.isArray(partitionData) ? partitionData : [partitionData]
+          
+          fileSystemInfo.partitions = partitionsArray.map(disk => {
+            const size = disk.Size ? parseInt(disk.Size) : 0
+            const freeSpace = disk.FreeSpace ? parseInt(disk.FreeSpace) : 0
+            const usedSpace = size - freeSpace
+            
+            return {
+              device: disk.DeviceID || 'N/A',
+              description: disk.Description || 'N/A',
+              filesystem: disk.FileSystem || 'N/A',
+              volumeName: disk.VolumeName || 'N/A',
+              size: size > 0 ? `${(size / (1024 * 1024 * 1024)).toFixed(2)} GB` : 'N/A',
+              freeSpace: freeSpace > 0 ? `${(freeSpace / (1024 * 1024 * 1024)).toFixed(2)} GB` : 'N/A',
+              usedSpace: usedSpace > 0 ? `${(usedSpace / (1024 * 1024 * 1024)).toFixed(2)} GB` : 'N/A',
+              usePercent: size > 0 ? `${((usedSpace / size) * 100).toFixed(2)}%` : 'N/A'
+            }
+          }).filter(item => item)
+
+          // 获取卷详细信息（Windows）
+          try {
+            const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_LogicalDisk | Select-Object VolumeName,VolumeSerialNumber,FileSystem,MaximumComponentLength,DeviceID,DriveType | ConvertTo-Json"')
+            const allVolumeData = JSON.parse(stdout)
+            const volumeArray = Array.isArray(allVolumeData) ? allVolumeData : [allVolumeData]
+            
+            fileSystemInfo.volumeInfo = volumeArray.map(vol => ({
+              device: vol.DeviceID || 'N/A',
+              volumeName: vol.VolumeName || 'N/A',
+              serialNumber: vol.VolumeSerialNumber || 'N/A',
+              fileSystem: vol.FileSystem || 'N/A',
+              maxComponentLength: vol.MaximumComponentLength || 'N/A',
+              deviceID: vol.DeviceID || 'N/A',
+              driveType: vol.DriveType === 2 ? 'Removable' : vol.DriveType === 3 ? 'Local' : vol.DriveType === 4 ? 'Network' : vol.DriveType === 5 ? 'CD-ROM' : 'Unknown'
+            })).filter(item => item)
+          } catch (error) {
+            console.error('Error getting volume info:', error)
+          }
+
+          // 获取磁盘健康状态（Windows SMART）
+          try {
+            const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_DiskDrive | Select-Object Model,Status,SerialNumber,Size,MediaType | ConvertTo-Json"')
+            const diskData = JSON.parse(stdout)
+            const diskArray = Array.isArray(diskData) ? diskData : [diskData]
+            fileSystemInfo.diskHealth = diskArray.map(disk => {
+              return {
+                model: disk.Model || 'N/A',
+                status: disk.Status || 'N/A',
+                serialNumber: disk.SerialNumber || 'N/A',
+                size: disk.Size ? `${(parseInt(disk.Size) / (1024 * 1024 * 1024)).toFixed(2)} GB` : 'N/A'
+              }
+            }).filter(item => item)
+          } catch (error) {
+            console.error('Error getting disk health:', error)
+          }
+        } catch (error) {
+          console.error('Error getting file system info:', error)
+          fileSystemInfo.error = 'Error getting file system info'
+        }
+      }
+      // 获取文件系统信息（Linux）
+      else if (os.platform() === 'linux') {
+        try {
+          const { stdout } = await execPromise('df -h')
+          fileSystemInfo.partitions = stdout.trim().split('\n').slice(1).map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 6) {
+              return {
+                device: parts[0],
+                size: parts[1],
+                usedSpace: parts[2],
+                freeSpace: parts[3],
+                usePercent: parts[4],
+                mountedOn: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+
+          // 获取挂载选项和文件系统类型（Linux）
+          try {
+            const { stdout } = await execPromise('mount | column -t')
+            const mountLines = stdout.trim().split('\n')
+            const mountInfo = {}
+            mountLines.forEach(line => {
+              const match = line.match(/^(.+?)\s+on\s+(.+?)\s+type\s+(.+?)\s+\((.*)\)$/)
+              if (match) {
+                mountInfo[match[2]] = {
+                  device: match[1],
+                  filesystem: match[3],
+                  options: match[4]
+                }
+              }
+            })
+            fileSystemInfo.mountInfo = mountInfo
+          } catch (error) {
+            console.error('Error getting mount info:', error)
+          }
+
+          // 获取inode信息（Linux）
+          try {
+            const { stdout } = await execPromise('df -i')
+            fileSystemInfo.inodeInfo = stdout.trim().split('\n').slice(1).map(line => {
+              const parts = line.trim().split(/\s+/)
+              if (parts.length >= 6) {
+                return {
+                  device: parts[0],
+                  totalInodes: parts[1],
+                  usedInodes: parts[2],
+                  freeInodes: parts[3],
+                  usePercent: parts[4],
+                  mountedOn: parts[5]
+                }
+              }
+              return null
+            }).filter(item => item)
+          } catch (error) {
+            console.error('Error getting inode info:', error)
+          }
+
+          // 获取磁盘健康状态（Linux SMART）
+          try {
+            const { stdout } = await execPromise('smartctl --health --json /dev/sda 2>/dev/null || echo "{}"')
+            if (stdout && stdout.includes('smart_status')) {
+              const healthData = JSON.parse(stdout)
+              fileSystemInfo.diskHealth.push({
+                device: '/dev/sda',
+                status: healthData.smart_status?.passed ? 'OK' : 'Failed',
+                powerOnHours: healthData.power_on_time?.hours || 'N/A',
+                temperature: healthData.temperature?.current || 'N/A'
+              })
+            }
+          } catch (error) {
+            console.log('SMART info not available or requires root')
+          }
+        } catch (error) {
+          console.error('Error getting file system info:', error)
+          fileSystemInfo.error = 'Error getting file system info'
+        }
+      }
+      // 获取文件系统信息（macOS）
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('df -h')
+          fileSystemInfo.partitions = stdout.trim().split('\n').slice(1).map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 6) {
+              return {
+                device: parts[0],
+                size: parts[1],
+                usedSpace: parts[2],
+                freeSpace: parts[3],
+                usePercent: parts[4],
+                mountedOn: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+
+          // 获取卷详细信息（macOS）
+          try {
+            const diskInfo = await execPromise('diskutil info -all')
+            const diskLines = diskInfo.stdout.trim().split('\n\n')
+            diskLines.forEach(disk => {
+              const volMatch = disk.match(/Volume Name:\s+(.+)/)
+              const devMatch = disk.match(/Device Node:\s+(.+)/)
+              const fsMatch = disk.match(/File System Personality:\s+(.+)/)
+              const serialMatch = disk.match(/Disk UUID:\s+(.+)/)
+              
+              if (devMatch) {
+                fileSystemInfo.volumeInfo.push({
+                  device: devMatch[1],
+                  volumeName: volMatch ? volMatch[1] : 'N/A',
+                  filesystem: fsMatch ? fsMatch[1] : 'N/A',
+                  serialNumber: serialMatch ? serialMatch[1] : 'N/A'
+                })
+              }
+            })
+          } catch (error) {
+            console.error('Error getting volume info:', error)
+          }
+
+          // 获取inode信息（macOS）
+          try {
+            const { stdout } = await execPromise('df -i')
+            fileSystemInfo.inodeInfo = stdout.trim().split('\n').slice(1).map(line => {
+              const parts = line.trim().split(/\s+/)
+              if (parts.length >= 6) {
+                return {
+                  device: parts[0],
+                  totalInodes: parts[1],
+                  usedInodes: parts[2],
+                  freeInodes: parts[3],
+                  usePercent: parts[4],
+                  mountedOn: parts[5]
+                }
+              }
+              return null
+            }).filter(item => item)
+          } catch (error) {
+            console.error('Error getting inode info:', error)
+          }
+
+          // 获取磁盘健康状态（macOS）
+          try {
+            const { stdout } = await execPromise('diskutil smartStatus -all 2>/dev/null || echo "N/A"')
+            if (stdout && stdout !== 'N/A') {
+              fileSystemInfo.diskHealth = stdout.trim()
+            }
+          } catch (error) {
+            console.log('SMART status not available')
+          }
+        } catch (error) {
+          console.error('Error getting file system info:', error)
+          fileSystemInfo.error = 'Error getting file system info'
+        }
+      }
+
+      return JSON.stringify(fileSystemInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting file system info:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_system_file_info",
+    description: `获取系统硬盘分区和文件系统信息，包括分区信息、卷标、序列号、磁盘健康状态、inode信息等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/hardware_info.js

@@ -0,0 +1,112 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取系统硬件配置信息工具
+ * @returns {string} - 返回系统硬件配置信息的 JSON 字符串
+ */
+export const getHardwareInfoTool = tool(
+  async (input) => {
+    try {
+      const hardwareInfo = {
+        cpu: {
+          cores: os.cpus().length,
+          model: os.cpus()[0].model,
+          speed: os.cpus()[0].speed
+        },
+        memory: {
+          total: `${(os.totalmem() / (1024 ** 3)).toFixed(2)} GB`,
+          free: `${(os.freemem() / (1024 ** 3)).toFixed(2)} GB`
+        },
+        disks: [],
+        gpu: []
+      }
+
+      // 获取硬盘信息（Windows）
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_DiskDrive | Select-Object Model,InterfaceType,Size | ConvertTo-Json"')
+          const diskData = JSON.parse(stdout)
+          const diskArray = Array.isArray(diskData) ? diskData : [diskData]
+          hardwareInfo.disks = diskArray.map(disk => ({
+            model: disk.Model || 'N/A',
+            interfaceType: disk.InterfaceType || 'N/A',
+            size: disk.Size ? `${(parseInt(disk.Size) / (1024 * 1024 * 1024)).toFixed(2)} GB` : 'N/A'
+          })).filter(item => item)
+        } catch (error) {
+          console.error('Error getting disk info:', error)
+        }
+
+        // 获取显卡信息（Windows）
+        try {
+          const { stdout } = await execPromise('wmic path win32_videocontroller get name')
+          hardwareInfo.gpu = stdout.trim().split('\n').slice(1).filter(line => line.trim())
+        } catch (error) {
+          console.error('Error getting GPU info:', error)
+        }
+      } 
+      // 获取硬盘和显卡信息（Linux）
+      else if (os.platform() === 'linux') {
+        try {
+          const { stdout } = await execPromise('lsblk -o NAME,MODEL,SIZE,TYPE | grep disk')
+          const diskLines = stdout.trim().split('\n')
+          hardwareInfo.disks = diskLines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 3) {
+              return {
+                name: parts[0],
+                model: parts.slice(1, -1).join(' '),
+                size: parts[parts.length - 1]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting disk info:', error)
+        }
+
+        try {
+          const { stdout } = await execPromise('lspci | grep VGA')
+          hardwareInfo.gpu = stdout.trim().split('\n').map(line => line.trim())
+        } catch (error) {
+          console.error('Error getting GPU info:', error)
+        }
+      }
+      // 获取硬盘和显卡信息（macOS）
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('diskutil list')
+          hardwareInfo.disks = [{
+            info: stdout.trim()
+          }]
+        } catch (error) {
+          console.error('Error getting disk info:', error)
+        }
+
+        try {
+          const { stdout } = await execPromise('system_profiler SPDisplaysDataType')
+          hardwareInfo.gpu = [{
+            info: stdout.trim()
+          }]
+        } catch (error) {
+          console.error('Error getting GPU info:', error)
+        }
+      }
+
+      return JSON.stringify(hardwareInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting hardware info:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_hardware_info",
+    description: `获取系统硬件配置信息，包括CPU、内存、硬盘、显卡等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/installed_software.js

@@ -0,0 +1,101 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取已安装软件信息工具
+ * @returns {string} - 返回已安装软件信息的 JSON 字符串
+ */
+export const getInstalledSoftwareTool = tool(
+  async (input) => {
+    try {
+      const softwareInfo = {
+        platform: os.platform(),
+        software: []
+      }
+
+      // 获取Windows已安装软件
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_Product | Select-Object Name,Version,Vendor,InstallDate | ConvertTo-Json"')
+          const softwareData = JSON.parse(stdout)
+          const softwareArray = Array.isArray(softwareData) ? softwareData : [softwareData]
+          softwareInfo.software = softwareArray.map(soft => ({
+            name: soft.Name || 'N/A',
+            version: soft.Version || 'N/A',
+            vendor: soft.Vendor || 'N/A',
+            installDate: soft.InstallDate || 'N/A'
+          })).filter(item => item)
+        } catch (error) {
+          console.error('Error getting installed software:', error)
+        }
+      }
+      // 获取Linux已安装软件
+      else if (os.platform() === 'linux') {
+        try {
+          // 尝试使用dpkg（Debian/Ubuntu）
+          const { stdout: dpkgOutput } = await execPromise('dpkg -l 2>/dev/null || echo "N/A"')
+          if (dpkgOutput && dpkgOutput !== 'N/A') {
+            const lines = dpkgOutput.trim().split('\n').slice(5)
+            softwareInfo.software = lines.map(line => {
+              const parts = line.trim().split(/\s+/)
+              if (parts.length >= 3) {
+                return {
+                  name: parts[1],
+                  version: parts[2],
+                  description: parts.slice(3).join(' ')
+                }
+              }
+              return null
+            }).filter(item => item)
+          } else {
+            // 尝试使用rpm（RHEL/CentOS）
+            const { stdout: rpmOutput } = await execPromise('rpm -qa 2>/dev/null || echo "N/A"')
+            if (rpmOutput && rpmOutput !== 'N/A') {
+              const lines = rpmOutput.trim().split('\n')
+              softwareInfo.software = lines.map(line => {
+                const match = line.match(/(.+)-(.+)-(.+)/)
+                if (match) {
+                  return {
+                    name: match[1],
+                    version: `${match[2]}-${match[3]}`
+                  }
+                }
+                return null
+              }).filter(item => item)
+            }
+          }
+        } catch (error) {
+          console.error('Error getting installed software:', error)
+        }
+      }
+      // 获取macOS已安装软件
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('find /Applications -name "*.app" -type d | sort')
+          const apps = stdout.trim().split('\n')
+          softwareInfo.software = apps.map(app => ({
+            name: app.split('/').pop().replace('.app', ''),
+            path: app
+          })).filter(item => item)
+        } catch (error) {
+          console.error('Error getting installed software:', error)
+        }
+      }
+
+      return JSON.stringify(softwareInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting installed software:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_installed_software",
+    description: `获取系统已安装的软件信息，包括软件名称、版本、供应商等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/os_info.js

@@ -0,0 +1,89 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取操作系统信息工具
+ * @returns {string} - 返回操作系统信息的 JSON 字符串
+ */
+export const getOsInfoTool = tool(
+  async (input) => {
+    try {
+      const osInfo = {
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        hostname: os.hostname(),
+        uptime: `${Math.round(os.uptime() / 3600)} hours`,
+        nodeVersion: process.version,
+        homeDir: os.homedir(),
+        tempDir: os.tmpdir(),
+        userInfo: os.userInfo()
+      }
+
+      // 获取Windows详细信息
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('powershell -Command "Get-WmiObject Win32_OperatingSystem | Select-Object Caption,Version,BuildNumber,OSArchitecture | ConvertTo-Json"')
+          const winInfo = JSON.parse(stdout)
+          osInfo.windows = {
+            caption: winInfo.Caption || 'N/A',
+            version: winInfo.Version || 'N/A',
+            buildNumber: winInfo.BuildNumber || 'N/A',
+            architecture: winInfo.OSArchitecture || 'N/A'
+          }
+        } catch (error) {
+          console.error('Error getting Windows info:', error)
+        }
+      }
+      // 获取Linux详细信息
+      else if (os.platform() === 'linux') {
+        try {
+          const { stdout } = await execPromise('cat /etc/os-release')
+          const lines = stdout.trim().split('\n')
+          const linuxInfo = {}
+          lines.forEach(line => {
+            const match = line.match(/(.+?)=(.+)/)
+            if (match) {
+              linuxInfo[match[1]] = match[2].replace(/"/g, '')
+            }
+          })
+          osInfo.linux = linuxInfo
+        } catch (error) {
+          console.error('Error getting Linux info:', error)
+        }
+      }
+      // 获取macOS详细信息
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('sw_vers')
+          const lines = stdout.trim().split('\n')
+          const macInfo = {}
+          lines.forEach(line => {
+            const match = line.match(/(.+?):\s+(.+)/)
+            if (match) {
+              macInfo[match[1]] = match[2]
+            }
+          })
+          osInfo.macOS = macInfo
+        } catch (error) {
+          console.error('Error getting macOS info:', error)
+        }
+      }
+
+      return JSON.stringify(osInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting OS info:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_os_info",
+    description: `获取操作系统信息，包括平台、架构、版本、主机名、运行时间等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/os_network_info.js

@@ -0,0 +1,242 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取系统网卡和网络连接信息工具
+ * @returns {string} - 返回网络信息的 JSON 字符串，包括网卡信息和网络连接信息
+ */
+export const getNetworkInfoTool = tool(
+  async (input) => {
+    try {
+      const networkInfo = {
+        platform: os.platform(),
+        networkInterfaces: [],
+        dnsServers: [],
+        gateway: []
+      }
+
+      // 获取网络接口信息（跨平台）
+      const interfaces = os.networkInterfaces()
+      for (const [name, addresses] of Object.entries(interfaces)) {
+        networkInfo.networkInterfaces.push({
+          name,
+          addresses: addresses.map(addr => ({
+            family: addr.family,
+            address: addr.address,
+            netmask: addr.netmask,
+            mac: addr.mac,
+            internal: addr.internal,
+            cidr: addr.cidr
+          }))
+        })
+      }
+
+      // 获取详细网络信息（Windows）
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('ipconfig /all')
+          const lines = stdout.trim().split('\n')
+          let currentAdapter = null
+          
+          lines.forEach(line => {
+            const adapterMatch = line.match(/适配器\s+(.+?):/)
+            if (adapterMatch) {
+              if (currentAdapter) {
+                networkInfo.networkInterfaces.push(currentAdapter)
+              }
+              currentAdapter = {
+                name: adapterMatch[1],
+                description: '',
+                macAddress: '',
+                dhcpEnabled: false,
+                ipAddress: [],
+                subnetMask: [],
+                defaultGateway: [],
+                dnsServers: []
+              }
+            } else if (currentAdapter) {
+              const descMatch = line.match(/描述\s+(.+)/)
+              if (descMatch) currentAdapter.description = descMatch[1].trim()
+              
+              const macMatch = line.match(/物理地址\s+:\s+(.+)/)
+              if (macMatch) currentAdapter.macAddress = macMatch[1].trim()
+              
+              const dhcpMatch = line.match(/DHCP 已启用\s+:\s+(.+)/)
+              if (dhcpMatch) currentAdapter.dhcpEnabled = dhcpMatch[1].trim() === '是'
+              
+              const ipMatch = line.match(/IPv4 地址\s+:\s+(.+)/)
+              if (ipMatch) currentAdapter.ipAddress.push(ipMatch[1].trim())
+              
+              const subnetMatch = line.match(/子网掩码\s+:\s+(.+)/)
+              if (subnetMatch) currentAdapter.subnetMask.push(subnetMatch[1].trim())
+              
+              const gatewayMatch = line.match(/默认网关\s+:\s+(.+)/)
+              if (gatewayMatch && gatewayMatch[1].trim()) currentAdapter.defaultGateway.push(gatewayMatch[1].trim())
+              
+              const dnsMatch = line.match(/DNS 服务器\s+:\s+(.+)/)
+              if (dnsMatch && dnsMatch[1].trim()) currentAdapter.dnsServers.push(dnsMatch[1].trim())
+            }
+          })
+          
+          if (currentAdapter) {
+            networkInfo.networkInterfaces.push(currentAdapter)
+          }
+        } catch (error) {
+          console.error('Error getting network config:', error)
+        }
+
+        // 获取DNS服务器（Windows）
+        try {
+          const { stdout } = await execPromise('nslookup localhost 2>&1')
+          const dnsMatch = stdout.match(/Server:\s+(.+)/)
+          if (dnsMatch) {
+            networkInfo.dnsServers.push(dnsMatch[1].trim())
+          }
+        } catch (error) {
+          console.error('Error getting DNS servers:', error)
+        }
+      }
+      // 获取详细网络信息（Linux）
+      else if (os.platform() === 'linux') {
+        try {
+          const { stdout } = await execPromise('ip addr show')
+          const lines = stdout.trim().split('\n')
+          let currentInterface = null
+          
+          lines.forEach(line => {
+            const interfaceMatch = line.match(/^\d+:\s+(\w+):/)
+            if (interfaceMatch) {
+              if (currentInterface) {
+                networkInfo.networkInterfaces.push(currentInterface)
+              }
+              currentInterface = {
+                name: interfaceMatch[1],
+                state: '',
+                macAddress: '',
+                ipAddress: [],
+                subnetMask: []
+              }
+            } else if (currentInterface) {
+              const stateMatch = line.match(/state\s+(\w+)/)
+              if (stateMatch) currentInterface.state = stateMatch[1]
+              
+              const macMatch = line.match(/link\/ether\s+([a-fA-F0-9:]+)/)
+              if (macMatch) currentInterface.macAddress = macMatch[1]
+              
+              const ipMatch = line.match(/inet\s+(\d+\.\d+\.\d+\.\d+)\/(\d+)/)
+              if (ipMatch) {
+                currentInterface.ipAddress.push(ipMatch[1])
+                const maskLength = parseInt(ipMatch[2])
+                currentInterface.subnetMask.push(maskLength)
+              }
+            }
+          })
+          
+          if (currentInterface) {
+            networkInfo.networkInterfaces.push(currentInterface)
+          }
+        } catch (error) {
+          console.error('Error getting network config:', error)
+        }
+
+        // 获取DNS服务器（Linux）
+        try {
+          const { stdout } = await execPromise('cat /etc/resolv.conf')
+          const dnsMatches = stdout.match(/nameserver\s+(.+)/g)
+          if (dnsMatches) {
+            networkInfo.dnsServers = dnsMatches.map(match => match.replace('nameserver', '').trim())
+          }
+        } catch (error) {
+          console.error('Error getting DNS servers:', error)
+        }
+
+        // 获取网关（Linux）
+        try {
+          const { stdout } = await execPromise('ip route show default')
+          const gatewayMatch = stdout.match(/default via (\d+\.\d+\.\d+\.\d+)/)
+          if (gatewayMatch) {
+            networkInfo.gateway.push(gatewayMatch[1])
+          }
+        } catch (error) {
+          console.error('Error getting gateway:', error)
+        }
+      }
+      // 获取详细网络信息（macOS）
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('ifconfig')
+          const lines = stdout.trim().split('\n')
+          let currentInterface = null
+          
+          lines.forEach(line => {
+            const interfaceMatch = line.match(/^(\w+):/)
+            if (interfaceMatch) {
+              if (currentInterface) {
+                networkInfo.networkInterfaces.push(currentInterface)
+              }
+              currentInterface = {
+                name: interfaceMatch[1],
+                status: '',
+                macAddress: '',
+                ipAddress: [],
+                subnetMask: []
+              }
+            } else if (currentInterface) {
+              const statusMatch = line.match(/status:\s+(\w+)/)
+              if (statusMatch) currentInterface.status = statusMatch[1]
+              
+              const macMatch = line.match(/ether\s+([a-fA-F0-9:]+)/)
+              if (macMatch) currentInterface.macAddress = macMatch[1]
+              
+              const ipMatch = line.match(/inet\s+(\d+\.\d+\.\d+\.\d+)\s+netmask\s+(0x[0-9a-fA-F]+)/)
+              if (ipMatch) {
+                currentInterface.ipAddress.push(ipMatch[1])
+                currentInterface.subnetMask.push(ipMatch[2])
+              }
+            }
+          })
+          
+          if (currentInterface) {
+            networkInfo.networkInterfaces.push(currentInterface)
+          }
+        } catch (error) {
+          console.error('Error getting network config:', error)
+        }
+
+        // 获取DNS服务器（macOS）
+        try {
+          const { stdout } = await execPromise('scutil --dns | grep nameserver | awk \'{print $3}\'')
+          networkInfo.dnsServers = stdout.trim().split('\n').filter(dns => dns)
+        } catch (error) {
+          console.error('Error getting DNS servers:', error)
+        }
+
+        // 获取网关（macOS）
+        try {
+          const { stdout } = await execPromise('netstat -nr | grep default')
+          const gatewayMatch = stdout.match(/default\s+(\d+\.\d+\.\d+\.\d+)/)
+          if (gatewayMatch) {
+            networkInfo.gateway.push(gatewayMatch[1])
+          }
+        } catch (error) {
+          console.error('Error getting gateway:', error)
+        }
+      }
+
+      return JSON.stringify(networkInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting network info:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_network_info",
+    description: `获取系统网卡和网络信息，包括网卡配置、IP地址、MAC地址、DNS服务器、网关等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/os_socket_info.js

@@ -0,0 +1,157 @@
+import * as z from "zod"
+import { tool } from "langchain"
+import os from 'os'
+import { promisify } from 'util'
+import { exec } from 'child_process'
+
+const execPromise = promisify(exec)
+
+/**
+ * 获取系统活动连接和Socket信息工具
+ * @returns {string} - 返回Socket信息的 JSON 字符串，包括活动连接和监听端口等
+ */
+export const getSocketInfoTool = tool(
+  async (input) => {
+    try {
+      const socketInfo = {
+        platform: os.platform(),
+        activeConnections: [],
+        listeningPorts: []
+      }
+
+      // 获取活动连接（Windows）
+      if (os.platform() === 'win32') {
+        try {
+          const { stdout } = await execPromise('netstat -ano')
+          const lines = stdout.trim().split('\n').slice(4)
+          socketInfo.activeConnections = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 5) {
+              return {
+                protocol: parts[0],
+                localAddress: parts[1],
+                foreignAddress: parts[2],
+                state: parts[3],
+                processId: parts[4]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting active connections:', error)
+        }
+
+        // 获取监听端口（Windows）
+        try {
+          const { stdout } = await execPromise('netstat -an | findstr LISTENING')
+          const lines = stdout.trim().split('\n')
+          socketInfo.listeningPorts = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 4) {
+              return {
+                protocol: parts[0],
+                localAddress: parts[1],
+                state: parts[3]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting listening ports:', error)
+        }
+      }
+      // 获取活动连接（Linux）
+      else if (os.platform() === 'linux') {
+        try {
+          const { stdout } = await execPromise('ss -tuln')
+          const lines = stdout.trim().split('\n').slice(1)
+          socketInfo.activeConnections = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 5) {
+              return {
+                protocol: parts[0],
+                state: parts[1],
+                localAddress: parts[4],
+                peerAddress: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting active connections:', error)
+        }
+
+        // 获取监听端口（Linux）
+        try {
+          const { stdout } = await execPromise('ss -tulpn')
+          const lines = stdout.trim().split('\n').slice(1)
+          socketInfo.listeningPorts = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 6) {
+              return {
+                protocol: parts[0],
+                state: parts[1],
+                localAddress: parts[4],
+                processInfo: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting listening ports:', error)
+        }
+      }
+      // 获取活动连接（macOS）
+      else if (os.platform() === 'darwin') {
+        try {
+          const { stdout } = await execPromise('netstat -an')
+          const lines = stdout.trim().split('\n').slice(2)
+          socketInfo.activeConnections = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 6) {
+              return {
+                protocol: parts[0],
+                localAddress: parts[3],
+                foreignAddress: parts[4],
+                state: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting active connections:', error)
+        }
+
+        // 获取监听端口（macOS）
+        try {
+          const { stdout } = await execPromise('netstat -an | grep LISTEN')
+          const lines = stdout.trim().split('\n')
+          socketInfo.listeningPorts = lines.map(line => {
+            const parts = line.trim().split(/\s+/)
+            if (parts.length >= 6) {
+              return {
+                protocol: parts[0],
+                localAddress: parts[3],
+                foreignAddress: parts[4],
+                state: parts[5]
+              }
+            }
+            return null
+          }).filter(item => item)
+        } catch (error) {
+          console.error('Error getting listening ports:', error)
+        }
+      }
+
+      return JSON.stringify(socketInfo, null, 2)
+    } catch (error) {
+      console.error('Error getting socket info:', error)
+      return JSON.stringify({ error: error.message }, null, 2)
+    }
+  },
+  {
+    name: "get_socket_info",
+    description: `获取系统活动连接和Socket信息，包括TCP/UDP连接、监听端口、进程ID等`,
+    schema: z.object({})
+  }
+)

agent/tools/system/system_time.js

@@ -0,0 +1,17 @@
+import * as z from "zod"
+import { tool } from "langchain"
+
+/**
+ * 获取系统时间工具
+ * @returns {string} - 返回当前系统时间
+ */
+export const getSystemTimeTool = tool(
+  (input) => {
+    return new Date().toLocaleString()
+  },
+  {
+    name: "get_system_time",
+    description: `获取当前系统时间`,
+    schema: z.object({})
+  }
+)

agent/tools/system/win_cmd.js

@@ -0,0 +1,74 @@
+import * as z from 'zod';
+import { tool } from 'langchain';
+import { spawn } from 'child_process';
+
+export const winCmdTool = tool(
+  async ({ command, cwd, timeout = 30000 }) => {
+    const workingDir = cwd || process.cwd();
+
+    return new Promise((resolve) => {
+      let stdout = '';
+      let stderr = '';
+      let killed = false;
+
+      const proc = spawn('cmd.exe', ['/c', command], {
+        cwd: workingDir,
+        shell: false,
+        windowsHide: true
+      });
+
+      const timer = setTimeout(() => {
+        killed = true;
+        proc.kill('SIGKILL');
+      }, timeout);
+
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        clearTimeout(timer);
+        if (killed) {
+          resolve(JSON.stringify({
+            success: false,
+            error: `Command timed out after ${timeout}ms`,
+            command,
+            cwd: workingDir
+          }));
+          return;
+        }
+        resolve(JSON.stringify({
+          success: code === 0,
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          command,
+          cwd: workingDir
+        }));
+      });
+
+      proc.on('error', (error) => {
+        clearTimeout(timer);
+        resolve(JSON.stringify({
+          success: false,
+          error: error.message,
+          command,
+          cwd: workingDir
+        }));
+      });
+    });
+  },
+  {
+    name: 'win_cmd',
+    description: '在 Windows 系统上执行 cmd.exe 命令行命令。适用于运行 Windows 批处理命令、文件系统操作命令（如 dir、copy、del、mkdir 等）。不支持 PowerShell 命令。',
+    schema: z.object({
+      command: z.string().describe('要执行的 cmd.exe 命令或命令组合，使用 && 连接多个命令，如 "dir /b" 或 "echo hello && dir"'),
+      cwd: z.string().optional().describe('执行命令的工作目录，默认为当前工作目录'),
+      timeout: z.number().optional().describe('命令执行超时时间(毫秒)，默认30000')
+    })
+  }
+);

agent/tools/web/fetch.js

@@ -0,0 +1,34 @@
+import { TavilyExtract } from "@langchain/tavily";
+import { tool } from "@langchain/core/tools";
+import * as z from "zod"
+
+const webFetchTool = tool(
+  async ({
+    extractDepth = "basic",
+    includeImages = false,
+    format = "markdown",
+    urls = [],
+  }) => {
+    const tavilyExtract = new TavilyExtract({
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      extractDepth,
+      includeImages,
+      format
+    });
+    return await tavilyExtract._call({ urls });
+  },
+  {
+    name: "web_fetch",
+    description: "Run a web fetch",
+    schema: z.object({
+      extractDepth: z.enum(["basic", "advanced"]).default("basic"),
+      includeImages: z.boolean().default(false),
+      format: z
+        .enum(["markdown", "json"])
+        .default("markdown"),
+      urls: z.array(z.string().describe("The urls")).default([]),
+    }),
+  },
+);
+
+export { webFetchTool };

agent/tools/web/http_get.js

@@ -0,0 +1,62 @@
+import { tool } from 'langchain';
+import * as z from 'zod';
+
+export const httpGetTool = tool(
+  async ({ url, headers = {}, timeout = 30000 }) => {
+    try {
+      new URL(url);
+    } catch (e) {
+      return JSON.stringify({ success: false, error: `Invalid URL: ${url}` });
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'User-Agent': 'XAgent-Bot/1.0',
+          ...headers
+        },
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      const contentType = response.headers.get('content-type') || '';
+      let body;
+
+      if (contentType.includes('application/json')) {
+        body = await response.json();
+      } else if (contentType.includes('text/') || contentType.includes('application/javascript')) {
+        body = await response.text();
+      } else {
+        const buffer = await response.arrayBuffer();
+        body = Buffer.from(buffer).toString('base64');
+      }
+
+      return JSON.stringify({
+        success: true,
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body
+      });
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        return JSON.stringify({ success: false, error: `Request timed out after ${timeout}ms` });
+      }
+      return JSON.stringify({ success: false, error: error.message });
+    }
+  },
+  {
+    name: 'http_get',
+    description: 'Send HTTP GET request and return response content. Supports custom headers and timeout settings.',
+    schema: z.object({
+      url: z.string().describe('Request URL'),
+      headers: z.record(z.string(), z.string()).optional().describe('Request headers'),
+      timeout: z.number().optional().describe('Timeout in milliseconds, default 30000')
+    })
+  }
+);

agent/tools/web/http_post.js

@@ -0,0 +1,88 @@
+import { tool } from "@langchain/core/tools";
+import z from "zod";
+
+const httpPostTool = tool(
+  async ({ url, body, headers = {}, contentType = 'json', timeout = 30000 }) => {
+    try {
+      new URL(url);
+    } catch (e) {
+      return { success: false, error: `Invalid URL: ${url}` };
+    }
+
+    let requestBody;
+    const requestHeaders = {
+      'User-Agent': 'XAgent-Bot/1.0',
+      ...headers
+    };
+
+    switch (contentType) {
+      case 'json':
+        requestHeaders['Content-Type'] = 'application/json';
+        requestBody = typeof body === 'string' ? body : JSON.stringify(body);
+        break;
+      case 'form':
+        requestHeaders['Content-Type'] = 'application/x-www-form-urlencoded';
+        if (typeof body === 'object') {
+          requestBody = new URLSearchParams(body).toString();
+        } else {
+          requestBody = body;
+        }
+        break;
+      case 'text':
+        requestHeaders['Content-Type'] = 'text/plain';
+        requestBody = typeof body === 'string' ? body : JSON.stringify(body);
+        break;
+      default:
+        requestBody = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: requestHeaders,
+        body: requestBody,
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      const responseContentType = response.headers.get('content-type') || '';
+      let responseBody;
+
+      if (responseContentType.includes('application/json')) {
+        responseBody = await response.json();
+      } else {
+        responseBody = await response.text();
+      }
+
+      return {
+        success: true,
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: responseBody
+      };
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        return { success: false, error: `Request timed out after ${timeout}ms` };
+      }
+      return { success: false, error: error.message };
+    }
+  },
+  {
+    name: "http_post",
+    description: "Send HTTP POST request. Supports JSON and form data.",
+    schema: z.object({
+      url: z.string().describe("Request URL"),
+      body: z.union([z.string(), z.object({})]).describe("Request body, can be string or JSON object"),
+      headers: z.record(z.string()).optional().describe("Request headers"),
+      contentType: z.enum(['json', 'form', 'text', 'raw']).optional().describe("Content type, default json"),
+      timeout: z.number().optional().describe("Timeout in milliseconds, default 30000")
+    }),
+  },
+);
+
+export { httpPostTool };

agent/tools/web/search.js

@@ -0,0 +1,35 @@
+import { TavilySearch } from "@langchain/tavily";
+import { tool } from "@langchain/core/tools";
+import * as z from "zod"
+
+const webSearchTool = tool(
+  async ({
+    query,
+    maxResults = 5,
+    topic = "general",
+    includeRawContent = false,
+  }) => {
+    const tavilySearch = new TavilySearch({
+      maxResults,
+      tavilyApiKey: process.env.TAVILY_API_KEY,
+      includeRawContent,
+      topic,
+    });
+    return await tavilySearch._call({ query });
+  },
+  {
+    name: "internet_search",
+    description: "Run a web search",
+    schema: z.object({
+      query: z.string().describe("The search query"),
+      maxResults: z.number().optional().default(5),
+      topic: z
+        .enum(["general", "news", "finance"])
+        .optional()
+        .default("general"),
+      includeRawContent: z.boolean().optional().default(false),
+    }),
+  },
+);
+
+export { webSearchTool };