deepfish-ai 1.0.28 → 2.0.2

package/src/AgentRobot/BaseAgentRobot/Brain.js

@@ -1,210 +0,0 @@
-const fs = require('fs-extra')
-const { EventEmitterSuper } = require('eventemitter-super')
-const BrainEvent = require('./BrainEvent.js')
-const MessageCompresser = require('./utils/MessageCompresser.js')
-const { creatClient, think, thinkByTool } = require('./utils/AIRequest.js')
-const lodash = require('lodash')
-
-class Brain extends EventEmitterSuper {
-  constructor(agentRobot) {
-    super()
-    this.messages = []
-    this.maxIterations = agentRobot.opt.maxIterations
-    this.maxContextLength = agentRobot.opt.aiConfig.maxContextLength
-    this.memoryFilePath = agentRobot.memoryFilePath
-    this.messageCompresser = new MessageCompresser(this)
-    this.aiConfig = agentRobot.opt.aiConfig
-    this.aiClient = creatClient(agentRobot.opt.aiConfig)
-    this.agentRobot = agentRobot
-    this.restoreMemory()
-  }
-  // 恢复记忆
-  restoreMemory() {
-    if (fs.existsSync(this.memoryFilePath)) {
-      const messages = fs.readJsonSync(this.memoryFilePath) || []
-      // 预处理
-      this.messages = this._initMessages(messages)
-    }
-  }
-  // 写入记忆
-  storeMemory(message) {
-    this.messages.push(message)
-    fs.writeJsonSync(this.memoryFilePath, this.messages, { spaces: 2 })
-    this.emit(BrainEvent.NEW_MESSAGE, message)
-  }
-  storeToolReport(toolId, toolReport) {
-    if (typeof toolReport === 'object') {
-      toolReport = JSON.stringify(toolReport)
-    }
-    const message = {
-      role: 'tool',
-      tool_call_id: toolId,
-      content: toolReport,
-    }
-    this.storeMemory(message)
-  }
-
-  clearMemory() {
-    fs.removeSync(this.memoryFilePath)
-  }
-  // 循环思考
-  async thinkLoop(goal) {
-    let maxIterations = this.maxIterations
-    if (this.messages.length === 0) {
-      // 初始化message
-      this.storeMemory({
-        role: 'system',
-        content: this.agentRobot.systemPrompt,
-      })
-      this.storeMemory({
-        role: 'user',
-        content: goal,
-      })
-    } else {
-      this.storeMemory({
-        role: 'user',
-        content: goal,
-      })
-    }
-    let messages = this.messages
-    if (maxIterations === -1) {
-      maxIterations = Infinity
-    }
-    const skillDescriptions = this.agentRobot.toolManager.descriptions
-    this.emit(BrainEvent.THINK_BEFORE, messages)
-    while (maxIterations-- > 0) {
-      try {
-        // 更新系统提示词
-        if (messages[0].role === 'system') {
-          this.agentRobot.updateSessionTime()
-          messages[0] = {
-            role: 'system',
-            content: this.agentRobot.systemPrompt,
-          }
-        }
-        // 压缩上下文
-        await this.messageCompresser.compress(messages)
-        const { message, content, tool_calls } = await thinkByTool(
-          this.aiClient,
-          this.aiConfig,
-          messages,
-          skillDescriptions,
-          () => {
-            this.emit(BrainEvent.SUB_THINK_BEFORE, messages)
-          },
-          () => {
-            this.emit(BrainEvent.SUB_THINK_AFTER, messages)
-          },
-          (thinkOutput) => {
-            this.emit(BrainEvent.SUB_STREAM_THINK_OUTPUT, messages, thinkOutput)
-          },
-          (contentOutput) => {
-            this.emit(
-              BrainEvent.SUB_STREAM_CONTENT_OUTPUT,
-              messages,
-              contentOutput,
-            )
-          },
-          (toolCallsOutput) => {
-            this.emit(
-              BrainEvent.SUB_STREAM_TOOL_CALLS_OUTPUT,
-              messages,
-              toolCallsOutput,
-            )
-          },
-          () => {
-            this.emit(BrainEvent.SUB_STREAM_END, messages)
-          },
-        )
-        this.storeMemory(message)
-        // 检查是否是任务完成的总结响应（没有工具调用且有内容）
-        if (tool_calls) {
-          await this.emitPromise(BrainEvent.SUB_USE_TOOL, tool_calls)
-        } else {
-          break
-        }
-      } catch (error) {
-        this.emit(BrainEvent.SUB_THINK_ERROR, messages, error)
-        return `AI response error: ${error.message}`
-      }
-    }
-    const lastMessageContent = messages[messages.length - 1]?.content || ''
-    this.emit(BrainEvent.THINK_AFTER, lastMessageContent)
-    return lastMessageContent
-  }
-
-  async think(systemPrompt, prompt, temperature) {
-    const messages = [
-      {
-        role: 'system',
-        content: systemPrompt,
-      },
-      {
-        role: 'user',
-        content: prompt,
-      },
-    ]
-    try {
-      const aiConfig = lodash.cloneDeep(this.aiConfig)
-      if (temperature) {
-        aiConfig.temperature = temperature
-      }
-      const result = await think(
-        this.aiClient,
-        aiConfig,
-        messages,
-        () => {
-          this.emit(BrainEvent.SUB_THINK_BEFORE, messages)
-        },
-        () => {
-          this.emit(BrainEvent.SUB_THINK_AFTER, messages)
-        },
-        (thinkOutput) => {
-          this.emit(BrainEvent.SUB_STREAM_THINK_OUTPUT, messages, thinkOutput)
-        },
-        (contentOutput) => {
-          this.emit(
-            BrainEvent.SUB_STREAM_CONTENT_OUTPUT,
-            messages,
-            contentOutput,
-          )
-        },
-        (toolCallsOutput) => {
-          this.emit(
-            BrainEvent.SUB_STREAM_TOOL_CALLS_OUTPUT,
-            messages,
-            toolCallsOutput,
-          )
-        },
-        () => {
-          this.emit(BrainEvent.SUB_STREAM_END, messages)
-        },
-      )
-      return result
-    } catch (error) {
-      this.emit(BrainEvent.SUB_THINK_ERROR, messages, error)
-      return `AI response error: ${error.message}`
-    }
-  }
-
-  _initMessages(messages) {
-    let lastMessage = messages[messages.length - 1]
-    while (
-      messages.length > 1 &&
-      !(
-        lastMessage.role === 'assistant' &&
-        !lastMessage.tool_calls &&
-        lastMessage.content
-      )
-    ) {
-      messages.pop()
-      lastMessage = messages[messages.length - 1]
-    }
-    return messages
-  }
-}
-
-module.exports = {
-  Brain,
-  BrainEvent
-}

package/src/AgentRobot/BaseAgentRobot/BrainEvent.js

@@ -1,17 +0,0 @@
-class BrainEvent {
-  static THINK_BEFORE = '1'
-  static SUB_THINK_BEFORE = '1.1'
-  static SUB_THINK_AFTER = '1.2'
-  static SUB_STREAM_THINK_OUTPUT = '1.3'
-  static SUB_STREAM_CONTENT_OUTPUT = '1.4'
-  static SUB_STREAM_TOOL_CALLS_OUTPUT = '1.5'
-  static SUB_STREAM_END = '1.6'
-  static SUB_USE_TOOL = '1.7'
-  static SUB_THINK_ERROR = '1.8'
-  static COMPRESS_MESSAGES_BEFORE = '1.9'
-  static COMPRESS_MESSAGES_AFTER = '1.10'
-  static NEW_MESSAGE = '1.11'
-  static THINK_AFTER = '2'
-}
-
-module.exports = BrainEvent

package/src/AgentRobot/BaseAgentRobot/Hand.js

@@ -1,119 +0,0 @@
-const { EventEmitterSuper } = require('eventemitter-super')
-
-const HandEvent = {
-  USE_TOOL_BEFORE: '1',
-  USE_TOOL_REPORT: '1.1',
-  USE_TOOL_ERROR: '1.2',
-  USE_TOOL_AFTER: '2',
-}
-
-class Hand extends EventEmitterSuper {
-  constructor(agentRobot) {
-    super()
-    this.agentRobot = agentRobot
-    this.maxBlockFileSize = agentRobot.opt.maxBlockFileSize || 20 // KB
-    this.tools = agentRobot.toolManager.functions
-  }
-
-  _parseToolCalls(tool_call) {
-    const { id, function: func } = tool_call
-    const { name, arguments: args } = func
-    let parsedArgs
-    try {
-      parsedArgs = typeof args === 'string' ? JSON.parse(args) : args
-    } catch (error) {
-      if (typeof args === 'string') {
-        parsedArgs = {
-          value: args,
-        }
-      }
-    }
-    return {
-      toolId: id,
-      funcArgs: parsedArgs,
-      funcName: name,
-    }
-  }
-
-  _getFunctionParamNames(fn) {
-    if (typeof fn !== 'function') return []
-    const src = fn.toString()
-    const match = src.match(/^[\s\S]*?\(([^)]*)\)/)
-    if (!match) return []
-    return match[1]
-      .split(',')
-      .map((item) => item.trim())
-      .filter(Boolean)
-      .map((item) => item.replace(/\s*=.*$/, '').trim())
-  }
-
-  _buildOrderedArgs(fn, funcArgs) {
-    if (funcArgs == null) return []
-    if (Array.isArray(funcArgs)) return funcArgs
-    if (typeof funcArgs !== 'object') return [funcArgs]
-    const paramNames = this._getFunctionParamNames(fn)
-    if (paramNames.length === 0) return Object.values(funcArgs)
-    return paramNames.map((name) => funcArgs[name])
-  }
-
-  _getRequiredParamNames(funcName) {
-    const descriptions = this.agentRobot.toolManager.descriptions
-    const current = descriptions.find((item) => item?.function?.name === funcName)
-    return current?.function?.parameters?.required || []
-  }
-
-  async useTools(tool_calls) {
-    for (const toolCall of tool_calls) {
-      const { toolId, funcArgs, funcName } = this._parseToolCalls(toolCall)
-      const toolFunctions = this.tools
-      this.emit(HandEvent.USE_TOOL_BEFORE, toolId, funcName, funcArgs)
-      if (toolFunctions[funcName]) {
-        try {
-          const requiredParams = this._getRequiredParamNames(funcName)
-          if (funcArgs && typeof funcArgs === 'object' && !Array.isArray(funcArgs)) {
-            const missingParams = requiredParams.filter((name) => funcArgs[name] === undefined)
-            if (missingParams.length > 0) {
-              throw new Error(`Missing required tool arguments for ${funcName}: ${missingParams.join(', ')}`)
-            }
-          }
-          const orderedArgs = this._buildOrderedArgs(toolFunctions[funcName], funcArgs)
-          let result = await toolFunctions[funcName](...orderedArgs)
-          let toolContent = JSON.stringify(result)
-          if (funcName !== 'requestAI') {
-            const MAX_CONTENT_SIZE = this.maxBlockFileSize * 1024
-            if (toolContent.length > MAX_CONTENT_SIZE) {
-              if (
-                typeof result === 'string' &&
-                result.length > MAX_CONTENT_SIZE
-              ) {
-                toolContent = {
-                  truncated: true,
-                  message:
-                    '文件内容过大，请使用executeJSCode工具编写脚本分块读取和处理文件，避免一次性读取整个文件内容到对话中。如果不是本地文件，建议创建或下载成本地文件后再进行分块读取。',
-                  preview: toolContent.substring(0, 1000) + '...',
-                }
-              } else {
-                toolContent = {
-                  truncated: true,
-                  message: '结果数据量过大，请使用更具体的查询或分块处理。',
-                  preview: toolContent.substring(0, 1000) + '...',
-                }
-              }
-            }
-          }
-          this.emit(HandEvent.USE_TOOL_REPORT, toolId, funcName, toolContent)
-        } catch (error) {
-          this.emit(HandEvent.USE_TOOL_ERROR, toolId, funcName, { error: true, message: error.message, stack: error.stack })
-        }
-        this.emit(HandEvent.USE_TOOL_AFTER, toolId, funcName, funcArgs)
-      } else {
-        this.emit(HandEvent.USE_TOOL_ERROR, toolId, funcName, { error: true, message: `Tool ${funcName} not found` })
-      }
-    }
-  }
-}
-
-module.exports = {
-  Hand,
-  HandEvent
-}

package/src/AgentRobot/BaseAgentRobot/Logger.js

@@ -1,114 +0,0 @@
-const dayjs = require('dayjs')
-const path = require('path')
-const fs = require('fs-extra')
-
-class Logger {
-  constructor(agentRobot) {
-    this.logDirPath = agentRobot.logDirPath
-    this.screenPrinter = agentRobot.screenPrinter
-    this.maxLogExpireTime = agentRobot.config.maxLogExpireTime
-    this.memorySpace = agentRobot.memorySpace
-    this.logTimeMap = new Map()
-    this.logId = agentRobot.logId || agentRobot.root.logId
-  }
-  clearAllLogs() {
-    const fileNames = fs.readdirSync(this.memorySpace)
-    const currentDate = dayjs()
-    fileNames.forEach((fileName) => {
-      // 如果是目录则进入logs目录，清除日志文件
-      const filePath = path.join(this.memorySpace, fileName)
-      if (fs.statSync(filePath).isDirectory()) {
-        const logDir = path.join(filePath, 'logs')
-        if (fs.existsSync(logDir) && fs.statSync(logDir).isDirectory()) {
-          const logFiles = fs.readdirSync(logDir)
-          logFiles.forEach((logFile) => {
-            if (logFile.startsWith('log-') && logFile.endsWith('.txt')) {
-              const logDate = dayjs(logFile.slice(4, -4))
-              if (currentDate.diff(logDate, 'day') > this.maxLogExpireTime) {
-                fs.removeSync(path.join(logDir, logFile))
-              }
-            }
-          })
-        }
-      }
-    })
-  }
-
-  logExecTime(id, description = '') {
-    if (this.maxLogExpireTime === 0) {
-      return false
-    }
-    if (this.logTimeMap.has(id)) {
-      const startTime = this.logTimeMap.get(id)
-      const duration = dayjs().diff(startTime, 'second')
-      this.logTimeMap.delete(id)
-      this.screenPrinter.logInfo(
-        `${description} Execution time: ${duration} seconds`,
-      )
-      this.logInfo(`${description} Execution time: ${duration} seconds`)
-    } else {
-      this.logTimeMap.set(id, dayjs())
-    }
-  }
-  logMessage(message) {
-    if (this.maxLogExpireTime === 0) {
-      return false
-    }
-    const logFile = path.join(
-      this.logDirPath,
-      `log-${this.logId}-${dayjs().format('YYYY-MM-DD HH')}.txt`,
-    )
-    const logFile2 = path.join(
-      this.logDirPath,
-      `log-messeage-${this.logId}.txt`,
-    )
-    try {
-      let logEntry = `[${new Date().toISOString()}][${message.role}] ${message.content}\n`
-      fs.appendFileSync(logFile, logEntry)
-      fs.appendFileSync(logFile2, logEntry)
-      return true
-    } catch (error) {
-      console.error('Failed to log message:', error.message)
-      return false
-    }
-  }
-  logCompress(messages) {
-    if (this.maxLogExpireTime === 0) {
-      return false
-    }
-    const logFile = path.join(
-      this.logDirPath,
-      `log-${this.logId}-${dayjs().format('YYYY-MM-DD HH')}.txt`,
-    )
-    try {
-      let logEntry = `[${new Date().toISOString()}][***COMPRESS START***] 
-      ${messages.map(m => `[${m.role}] ${m.content}`).join('\n')}
-      [***COMPRESS END***] 
-      `
-      fs.appendFileSync(logFile, logEntry)
-      return true
-    } catch (error) {
-      console.error('Failed to log compress:', error.message)
-      return false
-    }
-  }
-  logInfo(message) {
-    if (this.maxLogExpireTime === 0) {
-      return false
-    }
-    const logFile = path.join(
-      this.logDirPath,
-      `log-${this.logId}-${dayjs().format('YYYY-MM-DD HH')}.txt`,
-    )
-    try {
-      let logEntry = `[${new Date().toISOString()}][###############] ${message}\n`
-      fs.appendFileSync(logFile, logEntry)
-      return true
-    } catch (error) {
-      console.error('Failed to log info:', error.message)
-      return false
-    }
-  }
-}
-
-module.exports = Logger

package/src/AgentRobot/BaseAgentRobot/ScreenPrinter.js

@@ -1,49 +0,0 @@
-const aiConsole = require("./utils/aiConsole.js")
-
-class ScreenPrinter {
-    // 日志相关工具函数
-    logInfo(message) {
-      aiConsole.logInfo(message)
-    }
-    
-    logSuccess(message) {
-      aiConsole.logSuccess(message)
-    }
-    
-    logError(message) {
-      aiConsole.logError(message)
-    }
-    
-    logWarning(message) {
-      aiConsole.logWarning(message)
-    }
-    
-    logDisabled(message) {
-      aiConsole.logDisabled(message)
-    }
-    
-    writeLine(msg1, msg2 = '', color = 'blue') {
-      aiConsole.writeLine(msg1, msg2, color)
-    }
-    
-    // 流式输出
-    async streamOutput(text, color = '#9bed7f') {
-      return aiConsole.streamOutput(text, color)
-    }
-    
-    // 流式换行
-    async streamLineBreak() {
-      return aiConsole.streamLineBreak()
-    }
-    
-    
-    loading(label = 'Thinking...') {
-      return aiConsole.loading(label)
-    }
-    
-    log(msg, color) {
-      aiConsole.log(msg, color)
-    }
-}
-
-module.exports = ScreenPrinter