src/main/kotlin/JChatGPT.kt

@@ -1,17 +1,12 @@
 package top.jie65535.mirai
 
-import com.aallam.openai.api.chat.ChatCompletionChunk
 import com.aallam.openai.api.chat.ChatCompletionRequest
 import com.aallam.openai.api.chat.ChatMessage
 import com.aallam.openai.api.chat.ChatRole
 import com.aallam.openai.api.chat.ToolCall
 import com.aallam.openai.api.model.ModelId
 import io.ktor.util.collections.*
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import net.mamoe.mirai.console.command.CommandManager.INSTANCE.register
@@ -29,6 +24,7 @@ import net.mamoe.mirai.event.events.GroupMessageEvent
 import net.mamoe.mirai.event.events.MessageEvent
 import net.mamoe.mirai.message.data.*
 import net.mamoe.mirai.message.data.Image.Key.queryUrl
+import net.mamoe.mirai.message.data.MessageSource.Key.quote
 import net.mamoe.mirai.utils.ExternalResource.Companion.toExternalResource
 import net.mamoe.mirai.utils.info
 import top.jie65535.mirai.tools.*
@@ -65,7 +61,6 @@ object JChatGPT : KotlinPlugin(
         // 注册聊天权限
         PermissionService.INSTANCE.register(chatPermission, "JChatGPT Chat Permission")
         PluginConfig.reload()
-        PluginData.reload()
 
         // 设置Token
         LargeLanguageModels.reload()
@@ -149,14 +144,6 @@ object JChatGPT : KotlinPlugin(
                 "与 \"${event.senderName}\" 私聊中"
             }
         }
-
-        replace("{memory}") {
-            val memoryText = PluginData.contactMemory[event.subject.id]
-            if (memoryText.isNullOrEmpty()) {
-                "暂无相关记忆"
-            } else memoryText
-        }
-
         return prompt.toString()
     }
 
@@ -313,128 +300,59 @@ object JChatGPT : KotlinPlugin(
     private val thinkRegex = Regex("<think>[\\s\\S]*?</think>")
 
     private suspend fun startChat(event: MessageEvent) {
-        if (!requestMap.add(event.subject.id)) {
+        if (!requestMap.add(event.sender.id)) {
-            logger.warning("The current Contact is busy!")
+            event.subject.sendMessage("再等等...")
             return
         }
 
-        try {
+        val history = mutableListOf<ChatMessage>()
-            val history = mutableListOf<ChatMessage>()
+        if (PluginConfig.prompt.isNotEmpty()) {
-            if (PluginConfig.prompt.isNotEmpty()) {
+            val prompt = getSystemPrompt(event)
-                val prompt = getSystemPrompt(event)
+            if (PluginConfig.logPrompt) {
-                if (PluginConfig.logPrompt) {
+                logger.info("Prompt: $prompt")
-                    logger.info("Prompt: $prompt")
-                }
-                history.add(ChatMessage(ChatRole.System, prompt))
             }
-            val historyText = getHistory(event)
+            history.add(ChatMessage(ChatRole.System, prompt))
-            logger.info("History: $historyText")
+        }
-            history.add(ChatMessage.User(historyText))
+        val historyText = getHistory(event)
-
+        logger.info("History: $historyText")
+        history.add(ChatMessage.User(historyText))
 
+        try {
             var done: Boolean
             // 至少循环3次
             var retry = max(PluginConfig.retryMax, 3)
             do {
                 try {
                     val startedAt = OffsetDateTime.now().toEpochSecond().toInt()
-                    val responseFlow = chatCompletions(history)
+                    val response = chatCompletion(history)
-                    var responseMessageBuilder: StringBuilder? = null
-                    val responseToolCalls = mutableListOf<ToolCall.Function>()
-                    val toolCallTasks = mutableListOf<Deferred<ChatMessage>>()
-                    // 处理聊天流式响应
-                    responseFlow.collect { chunk ->
-                        val delta = chunk.choices[0].delta
-                        if (delta == null) return@collect
-
-                        // 处理内容更新
-                        if (delta.content != null) {
-                            if (responseMessageBuilder == null) {
-                                responseMessageBuilder = StringBuilder(delta.content)
-                            } else {
-                                responseMessageBuilder.append(delta.content)
-                            }
-                        }
-
-                        // 处理工具调用更新
-                        val toolCalls = delta.toolCalls
-                        if (toolCalls != null) {
-                            for (toolCallChunk in toolCalls) {
-                                val index = toolCallChunk.index
-                                val toolId = toolCallChunk.id
-                                val function = toolCallChunk.function
-                                // 新的请求
-                                if (index >= responseToolCalls.size) {
-                                    // 处理已完成的工具调用
-                                    responseToolCalls.lastOrNull()?.let { toolCall ->
-                                        toolCallTasks.add(async {
-                                            val functionResponse = toolCall.execute(event)
-                                            ChatMessage(
-                                                role = ChatRole.Tool,
-                                                toolCallId = toolCall.id,
-                                                name = toolCall.function.name,
-                                                content = functionResponse
-                                            )
-                                        })
-                                    }
-
-                                    // 加入新的工具调用
-                                    if (toolId != null && function != null) {
-                                        responseToolCalls.add(ToolCall.Function(toolId, function))
-                                    }
-                                } else if (function != null) {
-                                    // 拼接函数名字
-                                    if (function.nameOrNull != null) {
-                                        val currentTool = responseToolCalls[index]
-                                        responseToolCalls[index] = currentTool.copy(
-                                            function = currentTool.function.copy(
-                                                nameOrNull = currentTool.function.nameOrNull.orEmpty() + function.name
-                                            )
-                                        )
-                                    }
-                                    // 拼接函数参数
-                                    if (function.argumentsOrNull != null) {
-                                        val currentTool = responseToolCalls[index]
-                                        responseToolCalls[index] = currentTool.copy(
-                                            function = currentTool.function.copy(
-                                                argumentsOrNull = currentTool.function.argumentsOrNull.orEmpty() + function.arguments
-                                            )
-                                        )
-                                    }
-                                }
-                            }
-                        }
-                    }
-
                     // 移除思考内容
-                    val responseContent = responseMessageBuilder?.replace(thinkRegex, "")?.trim()
+                    val responseContent = response.content?.replace(thinkRegex, "")?.trim()
-                    // 记录AI回答
                     history.add(ChatMessage.Assistant(
                         content = responseContent,
-                        toolCalls = responseToolCalls
+                        name = response.name,
+                        toolCalls = response.toolCalls
                     ))
 
-                    // 处理最后一个工具调用
+                    if (response.toolCalls.isNullOrEmpty()) {
-                    if (responseToolCalls.size > toolCallTasks.size) {
-                        val toolCallMessage = responseToolCalls.last().let { toolCall ->
-                            val functionResponse = toolCall.execute(event)
-                            ChatMessage(
-                                role = ChatRole.Tool,
-                                toolCallId = toolCall.id,
-                                name = toolCall.function.name,
-                                content = functionResponse
-                            )
-                        }
-                        if (toolCallTasks.isNotEmpty()) {
-                            // 等待之前的所有工具完成
-                            history.addAll(toolCallTasks.awaitAll())
-                        }
-                        // 将最后一个也加入对话历史中
-                        history.add(toolCallMessage)
-                        // 如果调用中包含结束对话工具则表示完成，反之则继续循环
-                        done = history.any { it.name == "endConversation" }
-                    } else {
                         done = true
+                    } else {
+                        done = false
+                        // 处理函数调用
+                        for (toolCall in response.toolCalls) {
+                            require(toolCall is ToolCall.Function) { "Tool call is not a function" }
+                            val functionResponse = toolCall.execute(event)
+                            history.add(
+                                ChatMessage(
+                                    role = ChatRole.Tool,
+                                    toolCallId = toolCall.id,
+                                    name = toolCall.function.name,
+                                    content = functionResponse
+                                )
+                            )
+                            if (toolCall.function.name == "endConversation") {
+                                done = true
+                            }
+                        }
                     }
 
                     if (!done) {
@@ -442,6 +360,11 @@ object JChatGPT : KotlinPlugin(
                             buildString {
                                 append("系统提示：本次运行还剩${retry-1}轮")
 
+//                                if (response.toolCalls.isNullOrEmpty()) {
+//                                    append("\n在上一轮对话中未检测到调用任何工具，请检查工具调用语法是否正确？")
+//                                    append("\n如果你确实不需要调用其它工具比如发送消息，请调用`endConversation`来结束对话。")
+//                                }
+
                                 val newMessages = getAfterHistory(startedAt, event)
                                 if (newMessages.isNotEmpty()) {
                                     append("\n以下是上次运行至今的新消息\n\n$newMessages")
@@ -455,32 +378,224 @@ object JChatGPT : KotlinPlugin(
                     } else {
                         done = false
                         logger.warning("调用llm时发生异常，重试中", e)
-                        event.subject.sendMessage("出错了...正在重试...")
+                        event.subject.sendMessage(event.message.quote() + "出错了...正在重试...")
                     }
                 }
             } while (!done && 0 < --retry)
         } catch (ex: Throwable) {
             logger.warning(ex)
-            event.subject.sendMessage("很抱歉，发生异常，请稍后重试")
+            event.subject.sendMessage(event.message.quote() + "很抱歉，发生异常，请稍后重试")
         } finally {
             // 一段时间后才允许再次提问，防止高频对话
             launch {
-                delay(1.seconds)
+                delay(5.seconds)
-                requestMap.remove(event.subject.id)
+                requestMap.remove(event.sender.id)
             }
         }
     }
 
-    private val regexAtQq = Regex("""@(\d{5,12})""")
+//    private suspend fun startChat(event: MessageEvent) {
+//        if (!requestMap.add(event.sender.id)) {
+//            // CD中不再引用消息，否则可能导致和机器人无限循环对话
+//            event.subject.sendMessage("再等等...")
+//            return
+//        }
+//
+//        val history = mutableListOf<ChatMessage>()
+//        if (PluginConfig.prompt.isNotEmpty()) {
+//            val prompt = getSystemPrompt(event)
+//            if (PluginConfig.logPrompt) {
+//                logger.info("Prompt: $prompt")
+//            }
+//            history.add(ChatMessage(ChatRole.System, prompt))
+//        }
+//        val historyText = getHistory(event)
+//        logger.info("History: $historyText")
+//        history.add(ChatMessage.User(historyText))
+//
+//        try {
+//            var done = true
+//            // 至少重试两次
+//            var retry = max(PluginConfig.retryMax, 3)
+//            val finalToolCalls = mutableMapOf<Int, ToolCall.Function>()
+//            val contentBuilder = StringBuilder()
+//            do {
+//                finalToolCalls.clear()
+//                contentBuilder.setLength(0)
+//
+//                try {
+//                    var sent = false
+//                    // 流式处理响应
+//                    withTimeout(PluginConfig.timeout) {
+//                        chatCompletions(history, retry > 1).collect { chunk ->
+//                            val delta = chunk.choices[0].delta
+//                            if (delta == null) return@collect
+//
+//                            // 处理工具调用
+//                            val toolCalls = delta.toolCalls
+//                            if (toolCalls != null) {
+//                                for (toolCall in toolCalls) {
+//                                    val index = toolCall.index
+//                                    val toolId = toolCall.id
+//                                    val function = toolCall.function
+//                                    // 取出未完成的函数调用
+//                                    val incompleteCall = finalToolCalls[index]
+//                                    // 如果是新的函数调用，保存起来
+//                                    if (incompleteCall == null && toolId != null && function != null) {
+//                                        // 添加函数调用
+//                                        finalToolCalls[index] = ToolCall.Function(toolId, function)
+//                                    } else if (incompleteCall != null && function != null && function.argumentsOrNull != null) {
+//                                        // 更新参数内容
+//                                        finalToolCalls[index] = incompleteCall.copy(
+//                                            function = incompleteCall.function.copy(
+//                                                argumentsOrNull = incompleteCall.function.arguments + function.arguments
+//                                            )
+//                                        )
+//                                    }
+//                                }
+//                            }
+//
+//                            // 处理响应内容
+//                            val contentChunk = delta.content
+//                            // 避免连续发送多次，只拆分第一次进行发送
+//                            if (contentChunk != null && !sent) {
+//                                // 填入内容
+//                                contentBuilder.append(contentChunk)
+//                                sent = parseStreamingContent(contentBuilder, event)
+//                            }
+//                        }
+//                    }
+//
+//                    val lastBlock = contentBuilder.toString().trim()
+//                    if (lastBlock.isNotEmpty()) {
+//                        event.subject.sendMessage(
+//                            if (lastBlock.length > PluginConfig.messageMergeThreshold) {
+//                                event.buildForwardMessage {
+//                                    event.bot says toMessage(event.subject, lastBlock)
+//                                }
+//                            } else {
+//                                toMessage(event.subject, lastBlock)
+//                            }
+//                        )
+//                    }
+//
+//                    if (finalToolCalls.isNotEmpty()) {
+//                        val toolCalls = finalToolCalls.values.toList()
+//                        history.add(ChatMessage.Assistant(toolCalls = toolCalls))
+//                        for (toolCall in toolCalls) {
+//                            val functionResponse = toolCall.execute(event)
+//                            history.add(
+//                                ChatMessage(
+//                                    role = ChatRole.Tool,
+//                                    toolCallId = toolCall.id,
+//                                    name = toolCall.function.name,
+//                                    content = functionResponse
+//                                )
+//                            )
+//                            done = false
+//                        }
+//                    } else {
+//                        done = true
+//                    }
+//                } catch (e: Exception) {
+//                    if (retry <= 1) {
+//                        throw e
+//                    } else {
+//                        done = false
+//                        logger.warning("调用llm时发生异常，重试中", e)
+//                        event.subject.sendMessage(event.message.quote() + "出错了...正在重试...")
+//                    }
+//                }
+//            } while (!done && 0 < --retry)
+//        } catch (ex: Throwable) {
+//            logger.warning(ex)
+//            event.subject.sendMessage(event.message.quote() + "很抱歉，发生异常，请稍后重试")
+//        } finally {
+//            // 一段时间后才允许再次提问，防止高频对话
+//            launch {
+//                delay(10.seconds)
+//                requestMap.remove(event.sender.id)
+//            }
+//        }
+//    }
+
+//    /**
+//     * 解析流消息
+//     */
+//    private fun parseStreamingContent(contentBuilder: StringBuilder, event: MessageEvent): Boolean {
+//        // 处理推理内容
+//        val thinkBeginAt = contentBuilder.indexOf("<think")
+//        if (thinkBeginAt >= 0) {
+//            val thinkEndAt = contentBuilder.indexOf("</think>")
+//            if (thinkEndAt > 0) {
+//                // 去除思考内容
+//                contentBuilder.delete(thinkBeginAt, thinkEndAt + "</think>".length)
+//            }
+//            // 跳过本轮处理
+//            return false
+//        }
+//
+//        // 处理代码块
+//        val codeBlockBeginAt = contentBuilder.indexOf("```")
+//        if (codeBlockBeginAt >= 0) {
+//            val codeBlockEndAt = contentBuilder.indexOf("```", codeBlockBeginAt + 3)
+//            if (codeBlockEndAt >= 0) {
+//                val codeBlockContentBegin = contentBuilder.indexOf("\n", codeBlockBeginAt + 3)
+//                if (codeBlockContentBegin in codeBlockBeginAt..codeBlockEndAt) {
+//                    val codeBlockContent = contentBuilder.substring(codeBlockContentBegin, codeBlockEndAt).trim()
+//                    contentBuilder.delete(codeBlockBeginAt, codeBlockEndAt + 3)
+//                    launch {
+//                        // 发送代码块内容
+//                        event.subject.sendMessage(
+//                            if (codeBlockContent.length < PluginConfig.messageMergeThreshold) {
+//                                toMessage(event.subject, codeBlockContent)
+//                            } else {
+//                                // 消息内容太长则转为转发消息避免刷屏
+//                                event.buildForwardMessage {
+//                                    event.bot says toMessage(event.subject, codeBlockContent)
+//                                }
+//                            }
+//                        )
+//                    }
+//                }
+//            }
+//            // 跳过本轮处理
+//            return true
+//        }
+//
+//        // 徒手trimStart
+//        var contentBeginAt = 0
+//        while (contentBeginAt < contentBuilder.length) {
+//            if (contentBuilder[contentBeginAt].isWhitespace()) {
+//                contentBeginAt++
+//            } else {
+//                break
+//            }
+//        }
+//
+//        // 对空行进行分割输出
+//        val emptyLineAt = contentBuilder.indexOf("\n\n", contentBeginAt)
+//        if (emptyLineAt > 0) {
+//            val lineContent = contentBuilder.substring(contentBeginAt, emptyLineAt)
+//            contentBuilder.delete(0, emptyLineAt + 2)
+//            launch {
+//                // 发送消息内容
+//                event.subject.sendMessage(toMessage(event.subject, lineContent))
+//            }
+//            return true
+//        }
+//        return false
+//    }
+
+
+    private val regexAtQq = Regex("@(\\d+)")
 
     private val regexLaTeX = Regex(
-        """\\\((.+?)\\\)|""" +  // 匹配行内公式 \(...\)
+        "\\\\\\((.+?)\\\\\\)|" + // 匹配行内公式 \(...\)
-                """\\\[(.+?)\\]|""" +   // 匹配独立公式 \[...\]
+                "\\\\\\[(.+?)\\\\\\]|" + // 匹配独立公式 \[...\]
-                """\$(.+?)\$"""     // 匹配行内公式 $...$
+                "\\$\\s(.+?)\\s\\$|" // 匹配行内公式 $...$
     )
 
-    private val regexImage = Regex("""!\[(.*?)]\(([^\s"']+).*?\)""")
-
     private data class MessageChunk(val range: IntRange, val content: Message)
 
     /**
@@ -497,7 +612,6 @@ object JChatGPT : KotlinPlugin(
             PlainText(content)
         } else {
             val t = mutableListOf<MessageChunk>()
-            // @某人
             regexAtQq.findAll(content).forEach {
                 val qq = it.groups[1]?.value?.toLongOrNull()
                 if (qq != null && contact is Group) {
@@ -505,16 +619,6 @@ object JChatGPT : KotlinPlugin(
                 }
             }
 
-            // 图片
-            regexImage.findAll(content).forEach {
-                // val placeholder = it.groupValues[1]
-                val url = it.groupValues[2]
-                t.add(MessageChunk(
-                    it.range,
-                    Image(url)))
-            }
-
-            // LeTeX渲染
             regexLaTeX.findAll(content).forEach {
                 it.groups.forEach { group ->
                     if (group == null || group.value.isEmpty()) return@forEach
@@ -532,7 +636,6 @@ object JChatGPT : KotlinPlugin(
                 }
             }
 
-            // 构造消息链
             buildMessageChain {
                 var index = 0
                 for ((range, msg) in t.sortedBy { it.range.start }) {
@@ -560,12 +663,6 @@ object JChatGPT : KotlinPlugin(
         // 发送组合消息
         SendCompositeMessage(),
 
-        // 记忆代理
-        MemoryAppend(),
-
-        // 记忆修改
-        MemoryReplace(),
-
         // 结束循环
         StopLoopAgent(),
 
@@ -589,48 +686,44 @@ object JChatGPT : KotlinPlugin(
 
         // Epic 免费游戏
         EpicFreeGame(),
-
-        // 群管代理
-        GroupManageAgent(),
     )
 
-//    private suspend fun chatCompletion(
+
+//    private fun chatCompletions(
 //        chatMessages: List<ChatMessage>,
 //        hasTools: Boolean = true
-//    ): ChatMessage {
+//    ): Flow<ChatCompletionChunk> {
-//        val llm = LargeLanguageModels.chat ?: throw NullPointerException("OpenAI Token 未设置，无法开始")
+//        val llm = this.llm ?: throw NullPointerException("OpenAI Token 未设置，无法开始")
 //        val availableTools = if (hasTools) {
 //            myTools.filter { it.isEnabled }.map { it.tool }
 //        } else null
 //        val request = ChatCompletionRequest(
 //            model = ModelId(PluginConfig.chatModel),
-//            temperature = PluginConfig.chatTemperature,
 //            messages = chatMessages,
 //            tools = availableTools,
 //        )
 //        logger.info("API Requesting... Model=${PluginConfig.chatModel}")
-//        val response = llm.chatCompletion(request)
+//        return llm.chatCompletions(request)
-//        val message = response.choices.first().message
-//        logger.info("Response: $message ${response.usage}")
-//        return message
 //    }
 
-    private fun chatCompletions(
+    private suspend fun chatCompletion(
         chatMessages: List<ChatMessage>,
         hasTools: Boolean = true
-    ): Flow<ChatCompletionChunk> {
+    ): ChatMessage {
         val llm = LargeLanguageModels.chat ?: throw NullPointerException("OpenAI Token 未设置，无法开始")
         val availableTools = if (hasTools) {
             myTools.filter { it.isEnabled }.map { it.tool }
         } else null
         val request = ChatCompletionRequest(
             model = ModelId(PluginConfig.chatModel),
-            temperature = PluginConfig.chatTemperature,
             messages = chatMessages,
             tools = availableTools,
         )
         logger.info("API Requesting... Model=${PluginConfig.chatModel}")
-        return llm.chatCompletions(request)
+        val response = llm.chatCompletion(request)
+        val message = response.choices.first().message
+        logger.info("Response: $message ${response.usage}")
+        return message
     }
 
     private fun getNameCard(member: Member): String {

src/main/kotlin/PluginCommands.kt

@@ -45,7 +45,6 @@ object PluginCommands : CompositeCommand(
     @SubCommand
     suspend fun CommandSender.reload() {
         PluginConfig.reload()
-        PluginData.reload()
         LargeLanguageModels.reload()
         sendMessage("OK")
     }

src/main/kotlin/PluginConfig.kt

@@ -14,9 +14,6 @@ object PluginConfig : AutoSavePluginConfig("Config") {
     @ValueDescription("Chat模型")
     var chatModel: String by value("qwen-max")
 
-    @ValueDescription("Chat模型温度，默认为null")
-    var chatTemperature: Double? by value(null)
-
     @ValueDescription("推理模型API")
     var reasoningModelApi: String by value("https://dashscope.aliyuncs.com/compatible-mode/v1/")
 
@@ -50,9 +47,6 @@ object PluginConfig : AutoSavePluginConfig("Config") {
     @ValueDescription("好友是否自动拥有对话权限，默认是")
     val friendHasChatPermission: Boolean by value(true)
 
-    @ValueDescription("机器人是否可以禁言别人，默认禁止")
-    val canMute: Boolean by value(false)
-
     @ValueDescription("群荣誉等级权限门槛，达到这个等级相当于自动拥有对话权限。")
     val temperaturePermission: Int by value(50)
 

src/main/kotlin/PluginData.kt

@@ -1,35 +1,7 @@
 package top.jie65535.mirai
 
 import net.mamoe.mirai.console.data.AutoSavePluginData
-import net.mamoe.mirai.console.data.value
 
 object PluginData : AutoSavePluginData("data") {
-    /**
-     * 联系人记忆
-     */
-    val contactMemory by value(mutableMapOf<Long, String>())
 
-    /**
-     * 添加对话记忆
-     */
-    fun appendContactMemory(contactId: Long, newMemory: String) {
-        val memory = contactMemory[contactId]
-        if (memory.isNullOrEmpty()) {
-            contactMemory[contactId] = newMemory
-        } else {
-            contactMemory[contactId] = "$memory\n$newMemory"
-        }
-    }
-
-    /**
-     * 替换对话记忆
-     */
-    fun replaceContactMemory(contactId: Long, oldMemory: String, newMemory: String) {
-        val memory = contactMemory[contactId]
-        if (memory.isNullOrEmpty()) {
-            contactMemory[contactId] = newMemory
-        } else {
-            contactMemory[contactId] = memory.replace(oldMemory, newMemory)
-        }
-    }
 }

src/main/kotlin/tools/GroupManageAgent.kt

@@ -1,68 +0,0 @@
-package top.jie65535.mirai.tools
-
-import com.aallam.openai.api.chat.Tool
-import com.aallam.openai.api.core.Parameters
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.add
-import kotlinx.serialization.json.int
-import kotlinx.serialization.json.jsonPrimitive
-import kotlinx.serialization.json.long
-import kotlinx.serialization.json.put
-import kotlinx.serialization.json.putJsonArray
-import kotlinx.serialization.json.putJsonObject
-import net.mamoe.mirai.contact.MemberPermission
-import net.mamoe.mirai.event.events.GroupMessageEvent
-import net.mamoe.mirai.event.events.MessageEvent
-import top.jie65535.mirai.PluginConfig
-import kotlin.time.Duration.Companion.seconds
-
-class GroupManageAgent : BaseAgent(
-    tool = Tool.function(
-        name = "mute",
-        description = "可用于禁言指定群成员，只有你是管理员且目标非管理或群主时有效，非必要不要轻易禁言别人，否则你可能会被禁用这个特权！",
-        parameters = Parameters.buildJsonObject {
-            put("type", "object")
-            putJsonObject("properties") {
-                putJsonObject("target") {
-                    put("type", "integer")
-                    put("description", "目标QQ号")
-                }
-                putJsonObject("durationM") {
-                    put("type", "integer")
-                    put("description", "禁言时长（分钟，目前暂时只支持1~10分钟，后续视情况增加上限）")
-                }
-            }
-            putJsonArray("required") {
-                add("target")
-                add("durationM")
-            }
-        }
-    )
-) {
-    override val isEnabled: Boolean
-        get() = PluginConfig.canMute
-
-    override suspend fun execute(args: JsonObject?, event: MessageEvent): String {
-        requireNotNull(args)
-        val target = args.getValue("target").jsonPrimitive.long
-        val duration = args.getValue("durationM").jsonPrimitive.int
-        if (event !is GroupMessageEvent) {
-            return "非群聊环境无法禁言"
-        }
-        if (event.group.botPermission == MemberPermission.MEMBER) {
-            return "你并非管理，无法禁言他人"
-        }
-        val member = event.group[target]
-        if (member == null) {
-            return "未找到目标群成员"
-        }
-
-        if (member.isMuted) {
-            return "该目标已被禁言，还剩 " + member.muteTimeRemaining.seconds.toString() + " 解除。"
-        }
-
-        // 禁言指定时长
-        member.mute(duration.coerceIn(1, 10) * 60)
-        return "已禁言目标"
-    }
-}

src/main/kotlin/tools/MemoryAppend.kt

@@ -1,41 +0,0 @@
-package top.jie65535.mirai.tools
-
-import com.aallam.openai.api.chat.Tool
-import com.aallam.openai.api.core.Parameters
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.add
-import kotlinx.serialization.json.jsonPrimitive
-import kotlinx.serialization.json.put
-import kotlinx.serialization.json.putJsonArray
-import kotlinx.serialization.json.putJsonObject
-import net.mamoe.mirai.event.events.MessageEvent
-import top.jie65535.mirai.JChatGPT
-import top.jie65535.mirai.PluginData
-
-class MemoryAppend : BaseAgent(
-    tool = Tool.function(
-        name = "memoryAppend",
-        description = "新增记忆项",
-        parameters = Parameters.buildJsonObject {
-            put("type", "object")
-            putJsonObject("properties") {
-                putJsonObject("memory") {
-                    put("type", "string")
-                    put("description", "记忆项")
-                }
-            }
-            putJsonArray("required") {
-                add("memory")
-            }
-        }
-    )
-) {
-    override suspend fun execute(args: JsonObject?, event: MessageEvent): String {
-        requireNotNull(args)
-        val contactId = event.subject.id
-        val memoryText = args.getValue("memory").jsonPrimitive.content
-        JChatGPT.logger.info("Remember ($contactId): \"$memoryText\"")
-        PluginData.appendContactMemory(contactId, memoryText)
-        return "OK"
-    }
-}

src/main/kotlin/tools/MemoryReplace.kt

@@ -1,47 +0,0 @@
-package top.jie65535.mirai.tools
-
-import com.aallam.openai.api.chat.Tool
-import com.aallam.openai.api.core.Parameters
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.add
-import kotlinx.serialization.json.jsonPrimitive
-import kotlinx.serialization.json.put
-import kotlinx.serialization.json.putJsonArray
-import kotlinx.serialization.json.putJsonObject
-import net.mamoe.mirai.event.events.MessageEvent
-import top.jie65535.mirai.JChatGPT
-import top.jie65535.mirai.PluginData
-
-class MemoryReplace : BaseAgent(
-    tool = Tool.Companion.function(
-        name = "memoryReplace",
-        description = "替换记忆项",
-        parameters = Parameters.Companion.buildJsonObject {
-            put("type", "object")
-            putJsonObject("properties") {
-                putJsonObject("oldMemory") {
-                    put("type", "string")
-                    put("description", "原记忆项")
-                }
-                putJsonObject("newMemory") {
-                    put("type", "string")
-                    put("description", "新记忆项")
-                }
-            }
-            putJsonArray("required") {
-                add("oldMemory")
-                add("newMemory")
-            }
-        }
-    )
-) {
-    override suspend fun execute(args: JsonObject?, event: MessageEvent): String {
-        requireNotNull(args)
-        val contactId = event.subject.id
-        val oldMemoryText = args.getValue("oldMemory").jsonPrimitive.content
-        val newMemoryText = args.getValue("newMemory").jsonPrimitive.content
-        JChatGPT.logger.info("Replace memory ($contactId): \"$oldMemoryText\" -> \"$newMemoryText\"")
-        PluginData.replaceContactMemory(contactId, oldMemoryText, newMemoryText)
-        return "OK"
-    }
-}