foliko 1.0.31 → 1.0.32

package/.claude/settings.local.json

@@ -73,7 +73,9 @@
       "Bash(node -c plugins/email.js 2>&1)",
       "Bash(npm list:*)",
       "Bash(node -e \"const {EmailPlugin} = require\\('./plugins/email'\\); const p = new EmailPlugin\\(\\); console.log\\('email plugin loaded ok'\\); console.log\\('enabled:', p.enabled\\); console.log\\('version:', p.version\\);\" 2>&1)",
-      "Bash(cd D:/Code/vb-agent && node -e \"console.log\\('IMAP_HOST:', process.env.IMAP_HOST\\); console.log\\('IMAP_USER:', process.env.IMAP_USER\\); console.log\\('IMAP_PORT:', process.env.IMAP_PORT\\);\")"
+      "Bash(cd D:/Code/vb-agent && node -e \"console.log\\('IMAP_HOST:', process.env.IMAP_HOST\\); console.log\\('IMAP_USER:', process.env.IMAP_USER\\); console.log\\('IMAP_PORT:', process.env.IMAP_PORT\\);\")",
+      "Bash(node -e \"const sdk = require\\('@larksuiteoapi/node-sdk'\\); console.log\\(Object.keys\\(sdk\\)\\);\")",
+      "Bash(node -e \"const { WSClient } = require\\('@larksuiteoapi/node-sdk'\\); const sdk = new WSClient\\({}\\); console.log\\(Object.getOwnPropertyNames\\(Object.getPrototypeOf\\(sdk\\)\\)\\);\")"
     ]
   }
 }

package/package.json

@@ -1,43 +1,44 @@
-{
-  "name": "foliko",
-  "version": "1.0.31",
-  "description": "简约的插件化 Agent 框架",
-  "main": "src/index.js",
-  "bin": {
-    "foliko": "./cli/bin/foliko.js"
-  },
-  "scripts": {
-    "start": "node examples/basic.js",
-    "chat": "node cli/bin/foliko.js chat",
-    "test": "echo \"No tests yet\""
-  },
-  "keywords": [
-    "agent",
-    "ai",
-    "framework",
-    "plugin"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.58",
-    "@ai-sdk/mcp": "^1.0.25",
-    "@ai-sdk/openai": "^3.0.41",
-    "@ai-sdk/openai-compatible": "^2.0.35",
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@chnak/weixin-bot": "^1.2.0",
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "ai": "^6.0.116",
-    "dotenv": "^17.3.1",
-    "imap": "^0.8.19",
-    "imap-mkl": "^1.0.2",
-    "mailparser": "^3.7.2",
-    "marked": "^11.2.0",
-    "marked-terminal": "6",
-    "node-cron": "^4.2.1",
-    "node-telegram-bot-api": "^0.67.0",
-    "nodemailer": "^6.10.0",
-    "qrcode-terminal": "^0.12.0",
-    "zod": "^3.24.0"
-  }
-}
+{
+  "name": "foliko",
+  "version": "1.0.32",
+  "description": "简约的插件化 Agent 框架",
+  "main": "src/index.js",
+  "bin": {
+    "foliko": "./cli/bin/foliko.js"
+  },
+  "scripts": {
+    "start": "node examples/basic.js",
+    "chat": "node cli/bin/foliko.js chat",
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "framework",
+    "plugin"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/mcp": "^1.0.25",
+    "@ai-sdk/openai": "^3.0.41",
+    "@ai-sdk/openai-compatible": "^2.0.35",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@chnak/weixin-bot": "^1.2.0",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "ai": "^6.0.116",
+    "dotenv": "^17.3.1",
+    "imap": "^0.8.19",
+    "imap-mkl": "^1.0.2",
+    "mailparser": "^3.7.2",
+    "marked": "^11.2.0",
+    "marked-terminal": "6",
+    "node-cron": "^4.2.1",
+    "node-telegram-bot-api": "^0.67.0",
+    "nodemailer": "^6.10.0",
+    "qrcode-terminal": "^0.12.0",
+    "zod": "^3.24.0"
+  }
+}

package/plugins/default-plugins.js

@@ -443,7 +443,22 @@ async function bootstrapDefaults(framework, config = {}) {
     }
   }
 
-  // 12.9 SubAgent 管理器
+  // 12.9 Feishu 插件（默认禁用，需要在 plugins.json 中设置 enabled: true）
+  if (shouldLoad('feishu')) {
+    try {
+      const { Plugin } = require('../src/core/plugin-base')
+      const createFeishuPlugin = require('./feishu-plugin')
+      const FeishuPlugin = createFeishuPlugin(Plugin)
+      const feishuConfig = {
+        allowedUsers: agentConfig.feishu?.allowedUsers || []
+      }
+      await framework.loadPlugin(new FeishuPlugin(feishuConfig))
+    } catch (err) {
+      console.warn('[Bootstrap] Feishu Plugin not available:', err.message)
+    }
+  }
+
+  // 12.10 SubAgent 管理器
   if (shouldLoad('subagent-manager')) {
     try {
       const { SubAgentManagerPlugin } = require('./subagent-plugin')

package/plugins/email.js

@@ -307,13 +307,7 @@ class EmailPlugin extends Plugin {
 
             f.on('message', (msg) => {
               let email = {}
-              let parserDone = false
-
-              const finishEmail = () => {
-                if (parserDone) {
-                  emails.push(email)
-                }
-              }
+              let bodyParsed = false
 
               msg.on('body', (stream) => {
                 simpleParser(stream).then(mail => {
@@ -327,12 +321,10 @@ class EmailPlugin extends Plugin {
                     filename: a.filename,
                     contentType: a.contentType
                   })) || []
-                  parserDone = true
-                  finishEmail()
+                  bodyParsed = true
                 }).catch(err => {
                   email.error = err.message
-                  parserDone = true
-                  finishEmail()
+                  bodyParsed = true
                 })
               })
 
@@ -343,8 +335,15 @@ class EmailPlugin extends Plugin {
               })
 
               msg.on('end', () => {
-                // 如果没有 body，parserDone 已经是 true
-                finishEmail()
+                // 等待 body 解析完成后再加入列表
+                const checkDone = () => {
+                  if (bodyParsed) {
+                    emails.push(email)
+                  } else {
+                    setTimeout(checkDone, 10)
+                  }
+                }
+                checkDone()
               })
             })
 
@@ -354,8 +353,16 @@ class EmailPlugin extends Plugin {
             })
 
             f.on('end', () => {
-              cleanup()
-              resolve(emails)
+              // 等待所有邮件解析完成
+              const waitForAll = () => {
+                if (emails.length === fetchIds.length) {
+                  cleanup()
+                  resolve(emails)
+                } else {
+                  setTimeout(waitForAll, 10)
+                }
+              }
+              waitForAll()
             })
           })
         })

package/plugins/feishu-plugin.js

@@ -0,0 +1,612 @@
+/**
+ * 飞书插件
+ * 使用 @larksuiteoapi/node-sdk 的 WebSocket 长连接模式
+ *
+ * 配置：
+ * - appId: 飞书应用 ID (默认从 FEISHU_APP_ID 环境变量获取)
+ * - appSecret: 飞书应用密钥 (默认从 FEISHU_APP_SECRET 环境变量获取)
+ * - allowedUsers: 允许的用户 openId 数组，为空则允许所有用户
+ */
+
+const { Plugin } = require('../src/core/plugin-base')
+
+module.exports = function(Plugin) {
+  return class FeishuPlugin extends Plugin {
+    constructor(config = {}) {
+      super()
+      this.name = 'feishu'
+      this.version = '1.0.0'
+      this.description = '飞书对话插件，使用 WebSocket 长连接接收消息'
+      this.priority = 80
+      // 默认不启用，需要在 plugins.json 中设置 enabled: true
+      this.enabled = false
+
+      this.config = {
+        appId: config.appId || process.env.FEISHU_APP_ID,
+        appSecret: config.appSecret || process.env.FEISHU_APP_SECRET,
+        allowedUsers: config.allowedUsers || [],
+        systemPrompt: '你是一个飞书助手。回复内容不要使用markdown格式文本。'
+      }
+
+      this._framework = null
+      this._client = null
+      this._wsClient = null
+      this._sessionPlugin = null
+      this._sessionDeleteHandler = null
+      this._sessionAgents = new Map()  // openId -> Agent
+      this._initialized = false
+      this._processedMessages = new Set()  // 消息去重
+      this._messageCleanupInterval = null
+      this._processingLock = new Map()  // openId -> boolean (是否正在处理)
+    }
+
+    install(framework) {
+      this._framework = framework
+      return this
+    }
+
+    start(framework) {
+      // 防止重复初始化
+      if (this._initialized) return this
+      this._initialized = true
+
+      if (!this.config.appId || !this.config.appSecret) {
+        console.warn('[Feishu] No appId or appSecret. Set FEISHU_APP_ID and FEISHU_APP_SECRET env vars.')
+        return this
+      }
+
+      // 获取 SessionPlugin 引用
+      this._sessionPlugin = framework.pluginManager.get('session')
+
+      // 监听 SessionPlugin 的会话删除事件
+      if (this._sessionPlugin) {
+        this._sessionDeleteHandler = (sessionId) => {
+          // 只处理 feishu 会话的删除
+          if (sessionId.startsWith('feishu_')) {
+            console.log(`[Feishu] Session deleted: ${sessionId}`)
+          }
+        }
+        this._sessionPlugin.on('session:deleted', this._sessionDeleteHandler)
+      }
+
+      this._initClient()
+      return this
+    }
+
+    /**
+     * 初始化飞书 WebSocket 客户端
+     */
+    _initClient() {
+      try {
+        const { Client, WSClient, EventDispatcher } = require('@larksuiteoapi/node-sdk')
+
+        this._client = new Client({
+          appId: this.config.appId,
+          appSecret: this.config.appSecret,
+          logger: console
+        })
+
+        this._wsClient = new WSClient({
+          appId: this.config.appId,
+          appSecret: this.config.appSecret,
+          logger: console
+        })
+
+        // 创建事件分发器并注册处理器
+        const eventDispatcher = new EventDispatcher({}).register({
+          'im.message.receive_v1': async (data) => {
+            await this._handleMessage(data)
+          }
+        })
+
+        // 启动 WebSocket 连接
+        this._wsClient.start({ eventDispatcher })
+
+        // 启动消息去重清理定时器（每分钟清理一次）
+        this._messageCleanupInterval = setInterval(() => {
+          this._processedMessages.clear()
+        }, 60000)
+
+        // 监听定时提醒事件
+        if (this._framework) {
+          this._framework.on('scheduler:reminder', async (data) => {
+            console.log('[Feishu] Received scheduler reminder:', data)
+            await this._handleScheduledReminder(data)
+          })
+        }
+
+        console.log('[Feishu] WebSocket client started')
+      } catch (err) {
+        console.error('[Feishu] Failed to initialize client:', err.message, err.stack)
+      }
+    }
+
+    /**
+     * 处理飞书消息
+     */
+    async _handleMessage(data) {
+      try {
+        // 解析消息数据 - SDK 事件格式
+        // data 结构: { message: { chat_id, content, sender: { sender_id: { open_id }, ... }, message_type } }
+        if (!data || !data.message) {
+          console.log('[Feishu] Invalid message data:', JSON.stringify(data).substring(0, 500))
+          return
+        }
+
+        const message = data.message
+        const chatId = message.chat_id
+        const messageId = message.message_id
+        // 飞书消息结构: sender.sender_id.open_id 或 sender.open_id
+        // 注意: 群组消息可能没有 sender 字段，此时使用 chat_id 作为会话标识
+        const openId = message.sender?.sender_id?.open_id || message.sender?.open_id || message.open_id || chatId
+        const messageType = message.message_type
+        const content = message.content ? JSON.parse(message.content) : {}
+
+        // 消息去重
+        if (messageId && this._processedMessages.has(messageId)) {
+          console.log(`[Feishu] Duplicate message ignored: ${messageId}`)
+          return
+        }
+        if (messageId) {
+          this._processedMessages.add(messageId)
+        }
+
+        // 忽略非文本消息
+        if (messageType !== 'text') {
+          console.log(`[Feishu] Unsupported message type: ${messageType}`)
+          return
+        }
+
+        const text = content.text?.trim()
+        if (!text) {
+          console.log('[Feishu] Empty text message')
+          return
+        }
+
+        // 权限检查
+        if (!this._checkPermission(openId)) {
+          console.log(`[Feishu] User ${openId} not allowed`)
+          return
+        }
+
+        // 获取历史消息数量
+        let messageCount = 0
+        if (this._sessionPlugin) {
+          const session = this._sessionPlugin.getSession(`feishu_${openId}`)
+          messageCount = session?.messages?.length || 0
+        }
+
+        console.log(`[Feishu] #${messageCount + 1} | Chat: ${chatId} | User: ${openId}`)
+        console.log(`[Feishu] Content: ${text}`)
+
+        // 命令处理
+        if (text.startsWith('/')) {
+          await this._handleCommand(openId, text, message)
+          return
+        }
+
+        // 检查是否正在处理，防止并发
+        if (this._processingLock.get(openId)) {
+          console.log(`[Feishu] Session ${openId} is busy, ignoring message`)
+          return
+        }
+        this._processingLock.set(openId, true)
+
+        try {
+          await this._processChat(openId, text, message)
+        } finally {
+          this._processingLock.set(openId, false)
+        }
+
+      } catch (err) {
+        console.error('[Feishu] Error handling message:', err)
+      }
+    }
+
+    /**
+     * 处理命令
+     */
+    async _handleCommand(openId, text, originalMsg) {
+      const parts = text.split(' ')
+      const command = parts[0].substring(1)
+      const args = parts.slice(1).join(' ')
+
+      switch (command.toLowerCase()) {
+        case 'start':
+        case 'help':
+          await this._sendMessage(openId,
+            '👋 欢迎使用 AI 助手！\n\n' +
+            '直接发送消息即可与我对话。\n\n' +
+            '可用命令：\n' +
+            '/start - 显示帮助\n' +
+            '/clear - 清除对话历史\n' +
+            '/history - 查看历史消息数',
+            originalMsg)
+          break
+
+        case 'clear':
+          this._clearSession(openId)
+          await this._sendMessage(openId, '✅ 对话历史已清除', originalMsg)
+          break
+
+        case 'history':
+          if (this._sessionPlugin) {
+            const sessionId = `feishu_${openId}`
+            const session = this._sessionPlugin.getSession(sessionId)
+            const allSessions = this._sessionPlugin.listSessions()
+            const feishuSessionCount = allSessions.filter(s => s.id.startsWith('feishu_')).length
+            await this._sendMessage(openId,
+              `📊 当前状态\n\n会话数：${feishuSessionCount}\n` +
+              `历史消息：${session?.messages?.length || 0}\n` +
+              `最后活跃：${session?.lastActive?.toLocaleString() || '无'}`,
+              originalMsg)
+          } else {
+            await this._sendMessage(openId, '❌ 会话服务不可用', originalMsg)
+          }
+          break
+
+        default:
+          // 未识别命令，作为普通消息处理
+          await this._processChat(openId, text, originalMsg)
+      }
+    }
+
+    /**
+     * 获取或创建会话 Agent
+     * 使用 SessionPlugin 统一管理会话历史
+     */
+    _getSessionAgent(openId) {
+      // 检查缓存
+      if (this._sessionAgents.has(openId)) {
+        const agent = this._sessionAgents.get(openId)
+        console.log('[Feishu] Reusing cached session agent for openId:', openId)
+        return { agent, sessionId: `feishu_${openId}` }
+      }
+
+      // 创建新 agent
+      const agent = this._framework.createSessionAgent(`feishu_${openId}`, {
+        systemPrompt: this.config.systemPrompt
+      })
+      this._sessionAgents.set(openId, agent)
+      console.log('[Feishu] Created new session agent for openId:', openId)
+
+      // 使用 SessionPlugin 管理会话历史
+      if (this._sessionPlugin) {
+        const sessionId = `feishu_${openId}`
+        this._sessionPlugin.getOrCreateSession(sessionId, {
+          metadata: { platform: 'feishu', openId }
+        })
+      }
+
+      console.log(`[Feishu] Session ready for openId: ${openId}`)
+      return { agent, sessionId: `feishu_${openId}` }
+    }
+
+    /**
+     * 处理定时提醒
+     */
+    async _handleScheduledReminder(data) {
+      const { taskName, message, sessionId } = data
+
+      // 构建提醒消息
+      const reminderText = `🔔 [${taskName}]\n\n${message}`
+
+      // 如果有 sessionId 是 feishu 类型的，发送到对应用户
+      if (sessionId && sessionId.startsWith('feishu_')) {
+        const openId = sessionId.replace('feishu_', '')
+        try {
+          await this._sendTextMessage(openId, reminderText)
+          console.log(`[Feishu] Reminder sent to ${openId}`)
+        } catch (err) {
+          console.error(`[Feishu] Failed to send reminder:`, err.message)
+        }
+        return
+      }
+
+      // 其他情况，发送到最近的 Feishu 会话
+      if (this._sessionPlugin) {
+        const allSessions = this._sessionPlugin.listSessions()
+        const feishuSessions = allSessions
+          .filter(s => s.id.startsWith('feishu_'))
+          .sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime())
+
+        if (feishuSessions.length > 0) {
+          const openId = feishuSessions[0].id.replace('feishu_', '')
+          try {
+            await this._sendTextMessage(openId, reminderText)
+            console.log(`[Feishu] Reminder sent to ${openId}`)
+          } catch (err) {
+            console.error(`[Feishu] Failed to send reminder to ${openId}:`, err.message)
+          }
+        } else {
+          console.log('[Feishu] No active Feishu sessions to send reminder')
+        }
+      } else {
+        console.log('[Feishu] No active Feishu sessions to send reminder')
+      }
+    }
+
+    /**
+     * 发送纯文本消息（内部使用，不经过 markdown 处理）
+     */
+    async _sendTextMessage(openId, text) {
+      if (!this._client) return
+
+      try {
+        await this._client.im.message.create({
+          params: {
+            receive_id_type: 'chat_id'
+          },
+          data: {
+            receive_id: openId,
+            content: JSON.stringify({ text: text }),
+            msg_type: 'text'
+          }
+        })
+      } catch (err) {
+        console.error('[Feishu] Failed to send text message:', err.message)
+        throw err
+      }
+    }
+
+    /**
+     * 处理对话
+     */
+    async _processChat(openId, text, originalMsg) {
+      const sessionInfo = this._getSessionAgent(openId)
+      if (!sessionInfo) {
+        console.error('[Feishu] No session agent available')
+        return
+      }
+
+      const { agent, sessionId } = sessionInfo
+
+      // 使用 SessionPlugin 添加用户消息到历史
+      if (this._sessionPlugin) {
+        this._sessionPlugin.addMessage(sessionId, { role: 'user', content: text })
+      }
+
+      try {
+        let fullResponse = ''
+
+        // 使用流式响应
+        for await (const chunk of agent.chatStream(text, {
+          sessionId: sessionId
+        })) {
+          if (chunk.type === 'text' && chunk.text) {
+            fullResponse += chunk.text
+          }
+        }
+
+        // 保存助手回复到历史（使用 SessionPlugin）
+        if (this._sessionPlugin) {
+          this._sessionPlugin.addMessage(sessionId, { role: 'assistant', content: fullResponse })
+        }
+
+        // 发送回复
+        if (fullResponse) {
+          await this._sendMessage(openId, fullResponse, originalMsg)
+          console.log(`[Feishu] Reply sent (${fullResponse.length} characters)`)
+        } else {
+          await this._sendMessage(openId, '抱歉，我没有收到有效的回复。', originalMsg)
+        }
+
+      } catch (err) {
+        console.error('[Feishu] Chat error:', err)
+        await this._sendMessage(openId, `发生错误：${err.message}`, originalMsg)
+      }
+    }
+
+    /**
+     * 发送消息到飞书
+     * 使用 post 富文本类型
+     */
+    async _sendMessage(openId, text, originalMsg) {
+      if (!this._client) return
+
+      try {
+        // 获取用户所在的聊天 ID（回复到原消息所在的聊天）
+        const chatId = originalMsg?.chat_id || originalMsg?.message?.chat_id
+        if (!chatId) {
+          console.error('[Feishu] No chat_id found for reply')
+          return
+        }
+
+        // 暂时用 text 类型，等解决 post 权限问题后再切换
+        await this._client.im.message.create({
+          params: {
+            receive_id_type: 'chat_id'
+          },
+          data: {
+            receive_id: chatId,
+            content: JSON.stringify({ text: text }),
+            msg_type: 'text'
+          }
+        })
+      } catch (err) {
+        console.error('[Feishu] Failed to send message:', err.message, err.response?.data)
+      }
+    }
+
+    /**
+     * 构建飞书富文本内容
+     */
+    _buildPostContent(text) {
+      const lines = text.split('\n')
+      const paragraphs = []
+
+      for (const line of lines) {
+        if (line.trim() === '') {
+          paragraphs.push([{ tag: 'text', text: ' ' }])
+          continue
+        }
+
+        const segments = []
+        let remaining = line
+
+        while (remaining.length > 0) {
+          // 匹配加粗 **text**
+          const boldMatch = remaining.match(/^\*\*(.+?)\*\*/)
+          if (boldMatch) {
+            segments.push({ tag: 'text', text: boldMatch[1], bold: true })
+            remaining = remaining.slice(boldMatch[0].length)
+            continue
+          }
+
+          // 匹配斜体 *text* 或 _text_
+          const italicMatch = remaining.match(/^\*([^*]+?)\*|^_([^_]+?)_/)
+          if (italicMatch) {
+            const italicText = italicMatch[1] !== undefined ? italicMatch[1] : italicMatch[2]
+            segments.push({ tag: 'text', text: italicText, italic: true })
+            remaining = remaining.slice(italicMatch[0].length)
+            continue
+          }
+
+          // 匹配行内代码 `code`
+          const codeMatch = remaining.match(/^`([^`]+?)`/)
+          if (codeMatch) {
+            segments.push({ tag: 'text', text: codeMatch[1], code: true })
+            remaining = remaining.slice(codeMatch[0].length)
+            continue
+          }
+
+          // 匹配删除线 ~~text~~
+          const delMatch = remaining.match(/^~~(.+?)~~/)
+          if (delMatch) {
+            segments.push({ tag: 'text', text: delMatch[1], strikethrough: true })
+            remaining = remaining.slice(delMatch[0].length)
+            continue
+          }
+
+          // 匹配链接 [text](url)
+          const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/)
+          if (linkMatch) {
+            segments.push({ tag: 'a', text: linkMatch[1], href: linkMatch[2] })
+            remaining = remaining.slice(linkMatch[0].length)
+            continue
+          }
+
+          // 普通文本
+          const nextSpecial = remaining.search(/(\*|_|`|~~|\[)/)
+          if (nextSpecial === -1) {
+            segments.push({ tag: 'text', text: remaining })
+            break
+          } else if (nextSpecial === 0) {
+            segments.push({ tag: 'text', text: remaining[0] })
+            remaining = remaining.slice(1)
+          } else {
+            segments.push({ tag: 'text', text: remaining.slice(0, nextSpecial) })
+            remaining = remaining.slice(nextSpecial)
+          }
+        }
+
+        if (segments.length > 0) {
+          paragraphs.push(segments)
+        }
+      }
+
+      if (paragraphs.length === 0) {
+        paragraphs.push([{ tag: 'text', text: ' ' }])
+      }
+
+      return {
+        post: {
+          zh_cn: {
+            title: '',
+            content: paragraphs
+          }
+        }
+      }
+    }
+
+    /**
+     * 权限检查
+     */
+    _checkPermission(openId) {
+      if (!this.config.allowedUsers || this.config.allowedUsers.length === 0) {
+        return true
+      }
+      return this.config.allowedUsers.includes(openId)
+    }
+
+    /**
+     * 清除会话
+     */
+    _clearSession(openId) {
+      // 清除 SessionPlugin 中的会话（会触发 session:deleted 事件）
+      if (this._sessionPlugin) {
+        const sessionId = `feishu_${openId}`
+        this._sessionPlugin.deleteSession(sessionId)
+      }
+    }
+
+    /**
+     * 获取插件状态
+     */
+    getStatus() {
+      // 从 SessionPlugin 获取 Feishu 相关会话
+      let sessions = []
+      if (this._sessionPlugin) {
+        const allSessions = this._sessionPlugin.listSessions()
+        sessions = allSessions
+          .filter(s => s.id.startsWith('feishu_'))
+          .map(s => ({
+            openId: s.id.replace('feishu_', ''),
+            historyLength: s.messageCount,
+            lastActive: s.lastActive
+          }))
+      }
+
+      return {
+        connected: !!this._wsClient,
+        sessionCount: sessions.length,
+        sessions,
+        config: {
+          appId: this.config.appId ? `${this.config.appId.substring(0, 10)}...` : null,
+          allowedUsersCount: this.config.allowedUsers.length
+        }
+      }
+    }
+
+    /**
+     * 停止客户端
+     */
+    stopClient() {
+      if (this._wsClient) {
+        this._wsClient = null
+        this._client = null
+        console.log('[Feishu] Client stopped')
+      }
+    }
+
+    reload(framework) {
+      this._framework = framework
+      this._initialized = false
+      this.stopClient()
+      this.start(framework)
+    }
+
+    uninstall(framework) {
+      // 销毁所有 session agents
+      for (const agent of this._sessionAgents.values()) {
+        agent.destroy()
+      }
+      this._sessionAgents.clear()
+
+      // 清理去重定时器
+      if (this._messageCleanupInterval) {
+        clearInterval(this._messageCleanupInterval)
+        this._messageCleanupInterval = null
+      }
+      this._processedMessages.clear()
+
+      this.stopClient()
+      if (this._sessionPlugin && this._sessionDeleteHandler) {
+        this._sessionPlugin.off('session:deleted', this._sessionDeleteHandler)
+        this._sessionDeleteHandler = null
+      }
+      this._sessionPlugin = null
+      this._framework = null
+    }
+  }
+}

package/plugins/telegram-plugin.js

@@ -35,7 +35,7 @@ module.exports = function(Plugin) {
         allowedChats: config.allowedChats || [],
         groupMode: config.groupMode || false,
         prefix: config.prefix || '/',
-        systemPrompt: config.systemPrompt || '你是一个有帮助的AI助手。'
+        systemPrompt: config.systemPrompt || '你是一个有帮助的AI助手。回复内容不要使用markdown格式文本。'
       }
 
       this._framework = null

package/plugins/weixin-plugin.js

@@ -24,7 +24,7 @@ module.exports = function(Plugin) {
       this.config = {
         forceLogin: config.forceLogin || process.env.WEIXIN_FORCE_LOGIN === 'true',
         qrcodeTerminal: config.qrcodeTerminal !== false && process.env.WEIXIN_QRCODE_TERMINAL !== 'false',
-        systemPrompt: config.systemPrompt || '你是一个有帮助的AI助手。回复内容不要使用markdown格式文本',
+        systemPrompt: '你是一个微信助手。回复内容不要使用markdown格式文本',
         allowedUsers: config.allowedUsers || []
       }
 
@@ -159,7 +159,9 @@ module.exports = function(Plugin) {
       }
 
       // 创建新 agent
-      const agent = this._framework.createSessionAgent(`weixin_${userId}`)
+      const agent = this._framework.createSessionAgent(`weixin_${userId}`, {
+        systemPrompt: this.config.systemPrompt
+      })
       this._sessionAgents.set(userId, agent)
       console.log('[WeChat] Created new session agent for userId:', userId)