feat:定时消息+发送

main.py

@@ -1,52 +1,49 @@
 from astrbot.api.event import filter, AstrMessageEvent, MessageEventResult
-from astrbot.core.message.message_event_result import MessageChain
+
 from astrbot.api.star import Context, Star, register
 from astrbot.api import logger
 from astrbot.api.provider import (ProviderRequest,LLMResponse )
 from astrbot.core.agent.message import TextPart
-from tool.pattern import Pattern
+from .service.timer import TimerService
+
+
 @register("wait_msg", "Wbucket", "一个简单的 llm等待回复插件", "0.0.1")
 class MyPlugin(Star):
     def __init__(self, context: Context):
         super().__init__(context)
 
+        self.Timer = TimerService(self)
+
     async def initialize(self):
         """可选择实现异步的插件初始化方法，当实例化该插件类之后会自动调用该方法。"""
 
-    # 注册指令的装饰器。指令名为 helloworld。注册成功后，发送 `/helloworld` 就会触发这个指令，并回复 `你好, {user_name}!`
+    # 注册指令的装饰器
     @filter.on_llm_request()
     async def content_inject(self, event: AstrMessageEvent,req : ProviderRequest):
-        """这是一个 hello world 指令""" # 这是 handler 的描述，将会被解析方便用户了解插件内容。建议填写。
-        # logger.info("系统提示词："+req.system_prompt)
         req.extra_user_content_parts.append(TextPart(
             text=(
                 "-----wt使用----"
                 "在回复内容中加入<wt>n</wt>模板输入想要等待的时间,n=等待秒数\n"
-                "最短2s最长30min(1800s),不添加则正常回复(只有对方回复你才会被唤醒)\n"
-                "例如'<wt>5</wt>'-->等待5秒后再次唤醒.\n"
+                "最短10s最长30min(1800s),不添加则正常回复(只有对方回复你才会被唤醒)\n"
+                "例如'<wt>15</wt>'-->等待15秒后再次唤醒.\n"
                 "使用场景:希望对方在多久之后能回你，或者希望这个话题能在短期内继续而不是因为对方的不回复就夭折\n"
                 "例如如下场景:\n"
                 "--\n"
-                "assistant:'你觉得咸粽子好吃韩式甜粽子好吃?<wt>40</wt>'\n"
+                "assistant:'你觉得咸粽子好吃还是甜粽子好吃?<wt>40</wt>'\n"
                 "(系统时间：四十秒后,系统定时唤醒)\n"
-                "user:'<wt>无回应</wt>'\n"
+                "user:'<wt>40s过去了，对方无回应</wt>'\n"
                 "assistant:'你怎么不理我<wt>40</wt>'\n"
                 "(系统时间：二十秒后,用户回复，定时任务取消)\n"
                 "user:'抱歉啊刚看到，我觉得咸的好吃awa'\n"
-                "每主动回复消息必须带上wt标签，标签必须闭合且只包裹你要等待的秒数!\n"
+                "每主动发出消息建议带上wt标签，标签必须闭合且只包裹你要等待的秒数。\n"
+                "如果话题完结了，不想再无意义被唤醒，或者回复完毕别人的问题还没被追问的时候则不必再加。自己看着决定即可。\n"
                 "-------"
             )
         ))
-    # @filter.event_message_type(filter.EventMessageType.PRIVATE_MESSAGE)
-    # async def awa(self,event:AstrMessageEvent):
-    #     yield event.plain_result(event.get_message_str())
 
-    @filter.on_llm_response()
-    async def pattern_extract(self,event:AstrMessageEvent,req:LLMResponse):
-        if not req.role == 'assistant':
-            return
-        llm_res = req.completion_text
-        dump = Pattern(llm_res)
-        await event.send(MessageChain().message("awa定时时间消息:{0}过滤后:{1}".format(dump.count,dump.string)))
+    @filter.on_decorating_result()
+    async def pattern_extract(self,event:AstrMessageEvent):
+        self.Timer.parse(event)
+        
     async def terminate(self):
         """可选择实现异步的插件销毁方法，当插件被卸载/停用时会调用。"""

service/timer.py

@@ -0,0 +1,99 @@
+from astrbot.api.event import AstrMessageEvent
+from astrbot.api.provider import LLMResponse
+from astrbot.api import logger
+from astrbot.core.message.message_event_result import MessageChain,Plain
+from ..tool.pattern import Pattern
+from astrbot.api.star import Star
+import asyncio
+import json
+
+class TimerService:
+    def __init__(self,star:Star) -> None:
+        self.star = star
+        self.tasks:list[TimerTask] = []
+        pass
+
+    # 解析模板并进行定时
+    def parse(self,event:AstrMessageEvent):
+        res = event.get_result()       
+        if not res:
+            logger.warning("[wait_msg]:解析失败：没拿到消息链")
+            return
+
+        Second:int|None = None
+        logger.info("[wait_msg]:开始解析模板")
+        
+        for index,i in enumerate(res.chain) :
+            logger.info(f"获得消息链类型:{i.type}")
+            if not isinstance(i,Plain) or not i.type == "Plain":
+                continue
+            dump = Pattern(i.text)
+            i.text = dump.string
+            Second = dump.count
+            # 改变信息
+            res.chain[index] = i
+
+        event.set_result(res)
+        if not Second is None:
+            self.timer(event,Second)    
+        return 
+        
+
+    # 定时:
+    def timer(self,event:AstrMessageEvent,Sec:int):
+        logger.info(f"进行一个{Sec}秒的对{event.get_sender_id()}({event.get_sender_name()})的等")
+        task = asyncio.create_task(self.timer_task(event,Sec))
+        self.tasks.append(TimerTask(event=event,task=task))
+        
+    # 等待,唤醒任务本体
+    async def timer_task(self,event:AstrMessageEvent,second:int):
+        await asyncio.sleep(second)
+        await self.response_time(event)
+
+    # 调用llm
+    async def response_time(self,event:AstrMessageEvent):
+        try:
+            umo = event.unified_msg_origin
+            conv_mnger = self.star.context.conversation_manager
+            provider =await self.star.context.get_current_chat_provider_id(umo)
+            conv_id = await conv_mnger.get_curr_conversation_id(umo)
+            if conv_id is None:
+                logger.error(f"conversation_id获取失败!!umo:{umo}")
+                return False
+            conversation = await conv_mnger.get_conversation(umo,conv_id)
+            if conversation is None :
+                conversation = [] 
+            try:
+                history_list = json.loads(conversation.history)
+            except:
+                logger.warning("上下文获取失败,使用空上下文喵")
+                history_list = []
+
+        except:
+            logger.error("消息管理失败!")
+            return False
+        # logger.debug(f"获取上下文:{conversation}")
+        try:
+            req = await self.star.context.llm_generate(
+            chat_provider_id=provider,
+            prompt="<你等待的时间内对方没有回复>",
+            contexts=history_list,
+            tools=None
+
+        )
+        except:
+            logger.error("llm返回失败了喵...QAQ")
+            return
+        logger.debug(f"llm结果:{req.completion_text }")
+
+        # 保存至历史消息
+
+        #发送至平台
+        await event.send(MessageChain().message(req.completion_text))
+
+class TimerTask:
+    def __init__(self,event:AstrMessageEvent,task:asyncio.Task) -> None:
+        self.event = event
+        self.task = task
+        pass
+

tool/pattern.py

@@ -1,5 +1,7 @@
 import re
+from astrbot.api import logger
 
+# 输入内容，获取过滤后的字符串与定时秒数
 class Pattern:
     _pattern = r'<wt>((?!wt).)*</wt>'
 
@@ -7,6 +9,7 @@ class Pattern:
     _MIN_SEC = 10
     # 定义最大与最小的范围，固定输入的规范
     def __init__(self,o_str:str) -> None:
+        logger.debug(f"模板消息:{o_str}")
         res = self.extract(o_str)
         self.count:int|None = res['second']
         self.string:str = res["content"]
@@ -22,11 +25,12 @@ class Pattern:
 
     def load(self,pattern_str:str)->int|None:
         content = pattern_str.strip().removeprefix("<wt>").removesuffix("</wt>").strip()
-        print(content)
+
         try:
             num = int(content)
             return self.sec_range(num) 
         except:
+            logger.warning ("模板内容错误:{}".format(content))
             return None
 
     def extract(self,o_str:str):
@@ -37,11 +41,15 @@ class Pattern:
             # 对结果和源字符串处理
             o_str = o_str.replace(i.group(),"",1)
             num = self.load(i.group())
-            if num and timerSec:
+            logger.info("获得模板:{0}".format(i.group()))
+
+            if num and not timerSec:
                 timerSec = num
         #消除不完整/非法模板
         o_str= o_str.replace("<wt>","")
         o_str=o_str.replace("</wt>","")
+        logger.debug(f"过滤后消息:{o_str}")
+
         return {
             "content":o_str,
             "second":timerSec