feat:初版

plugins/ChatRoomSummary/__init__.py

@@ -0,0 +1 @@
+# 群聊总结插件

plugins/ChatRoomSummary/main.py

@@ -0,0 +1,708 @@
+"""
+群聊总结插件
+
+基于AI的群聊消息总结功能，支持定时总结和手动触发
+"""
+
+import tomllib
+import asyncio
+import aiohttp
+import pymysql
+from pathlib import Path
+from datetime import datetime, timedelta
+from loguru import logger
+from typing import List, Dict, Optional
+from utils.plugin_base import PluginBase
+from utils.decorators import on_text_message, schedule
+
+
+class ChatRoomSummary(PluginBase):
+    """群聊总结插件"""
+
+    description = "AI群聊总结 - 自动总结群聊话题和活跃度"
+    author = "Assistant"
+    version = "1.0.0"
+
+    def __init__(self):
+        super().__init__()
+        self.config = None
+        self.db_config = None
+
+    async def async_init(self):
+        """异步初始化"""
+        try:
+            config_path = Path(__file__).parent / "config.toml"
+            if not config_path.exists():
+                logger.error(f"群聊总结插件配置文件不存在: {config_path}")
+                return
+                
+            with open(config_path, "rb") as f:
+                self.config = tomllib.load(f)
+
+            self.db_config = self.config["database"]
+            logger.success("群聊总结插件已加载")
+            
+            # 测试数据库连接
+            try:
+                with self.get_db_connection() as conn:
+                    logger.info("数据库连接测试成功")
+            except Exception as e:
+                logger.error(f"数据库连接测试失败: {e}")
+                
+        except Exception as e:
+            logger.error(f"群聊总结插件初始化失败: {e}")
+            self.config = None
+
+    def get_db_connection(self):
+        """获取数据库连接"""
+        return pymysql.connect(
+            host=self.db_config["host"],
+            port=self.db_config["port"],
+            user=self.db_config["user"],
+            password=self.db_config["password"],
+            database=self.db_config["database"],
+            charset=self.db_config["charset"],
+            autocommit=True
+        )
+
+    @on_text_message(priority=85)
+    async def handle_summary_command(self, bot, message: dict):
+        """处理总结命令"""
+        if self.config is None:
+            return True
+            
+        content = message.get("Content", "").strip()
+        from_wxid = message.get("FromWxid", "")
+        sender_wxid = message.get("SenderWxid", "")
+        is_group = message.get("IsGroup", False)
+
+        if not is_group or not (content in ["/总结", "/群聊总结", "/昨日总结"] or content.startswith("/总结 ")):
+            return True
+
+        if not self.config["behavior"]["enabled"]:
+            return True
+
+        enabled_groups = self.config["behavior"]["enabled_groups"]
+        disabled_groups = self.config["behavior"]["disabled_groups"]
+
+        if from_wxid in disabled_groups or (enabled_groups and from_wxid not in enabled_groups):
+            return True
+
+        is_today = content.startswith("/总结 今日")
+        summary_type = "今日" if is_today else "昨日"
+        
+        logger.info(f"收到{summary_type}群聊总结请求: {from_wxid}")
+        await bot.send_text(from_wxid, f"🤖 正在生成{summary_type}群聊总结，请稍候...")
+
+        try:
+            summary = await self._generate_summary(from_wxid, is_today)
+            if summary:
+                await self._send_summary_as_chat_record(bot, from_wxid, summary, summary_type)
+            else:
+                await bot.send_text(from_wxid, f"❌ 生成{summary_type}总结失败，可能是聊天记录不足或AI服务异常")
+        except Exception as e:
+            logger.error(f"{summary_type}群聊总结失败: {e}")
+            await bot.send_text(from_wxid, f"❌ {summary_type}总结失败: {str(e)}")
+
+        return False
+
+    @schedule('cron', hour=9, minute=0)
+    async def daily_summary_task(self, bot):
+        """每日定时总结任务"""
+        if not self.config or not self.config["behavior"]["auto_summary_enabled"]:
+            return
+
+        logger.info("开始执行每日群聊总结任务")
+        enabled_groups = self.config["behavior"]["enabled_groups"]
+        disabled_groups = self.config["behavior"]["disabled_groups"]
+
+        if not enabled_groups:
+            logger.info("未配置启用自动总结的群聊，跳过任务")
+            return
+
+        success_count = 0
+        fail_count = 0
+
+        for group_id in enabled_groups:
+            if group_id in disabled_groups:
+                continue
+
+            try:
+                logger.info(f"为群聊 {group_id} 生成总结")
+                summary = await asyncio.wait_for(
+                    self._generate_summary(group_id),
+                    timeout=600
+                )
+                if summary:
+                    await self._send_summary_as_chat_record(bot, group_id, summary, "昨日")
+                    logger.success(f"群聊 {group_id} 总结发送成功")
+                    success_count += 1
+                else:
+                    logger.warning(f"群聊 {group_id} 总结生成失败（消息不足或其他原因）")
+                    fail_count += 1
+
+                await asyncio.sleep(60)
+            except asyncio.TimeoutError:
+                logger.error(f"群聊 {group_id} 总结超时（>600s）")
+                fail_count += 1
+            except Exception as e:
+                logger.error(f"群聊 {group_id} 总结失败: {e}")
+                import traceback
+                logger.error(traceback.format_exc())
+                fail_count += 1
+
+        logger.info(f"每日群聊总结任务完成 - 成功: {success_count}, 失败: {fail_count}")
+
+    async def _generate_summary(self, group_id: str, is_today: bool = False) -> Optional[str]:
+        """生成群聊总结"""
+        try:
+            if is_today:
+                messages = await self._get_today_messages(group_id)
+                time_desc = "今日"
+            else:
+                messages = await self._get_yesterday_messages(group_id)
+                time_desc = "昨日"
+            
+            if len(messages) < self.config["behavior"]["min_messages"]:
+                logger.info(f"群聊 {group_id} {time_desc}消息数量不足 ({len(messages)} < {self.config['behavior']['min_messages']})")
+                return None
+
+            formatted_messages = self._format_messages(messages)
+            summary = await self._call_ai_api(formatted_messages, group_id, time_desc)
+            return summary
+
+        except Exception as e:
+            logger.error(f"生成总结失败: {e}")
+            return None
+
+    async def _get_yesterday_messages(self, group_id: str) -> List[Dict]:
+        """获取昨日群聊消息"""
+        try:
+            today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            yesterday_start = today - timedelta(days=1)
+            yesterday_end = today
+
+            with self.get_db_connection() as conn:
+                with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                    sql = """
+                    SELECT sender_wxid, nickname, content, create_time, msg_type
+                    FROM messages 
+                    WHERE group_id = %s 
+                      AND is_group = 1 
+                      AND msg_type = 'text'
+                      AND create_time >= %s 
+                      AND create_time < %s
+                      AND LENGTH(TRIM(content)) > 0
+                    ORDER BY create_time ASC
+                    """
+                    cursor.execute(sql, (group_id, yesterday_start, yesterday_end))
+                    messages = cursor.fetchall()
+
+            logger.info(f"获取到群聊 {group_id} 昨日消息 {len(messages)} 条")
+            return messages
+
+        except Exception as e:
+            logger.error(f"获取昨日消息失败: {e}")
+            return []
+
+    async def _get_today_messages(self, group_id: str) -> List[Dict]:
+        """获取今日群聊消息"""
+        try:
+            today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            tomorrow = today + timedelta(days=1)
+
+            with self.get_db_connection() as conn:
+                with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                    sql = """
+                    SELECT sender_wxid, nickname, content, create_time, msg_type
+                    FROM messages 
+                    WHERE group_id = %s 
+                      AND is_group = 1 
+                      AND msg_type = 'text'
+                      AND create_time >= %s 
+                      AND create_time < %s
+                      AND LENGTH(TRIM(content)) > 0
+                    ORDER BY create_time ASC
+                    """
+                    cursor.execute(sql, (group_id, today, tomorrow))
+                    messages = cursor.fetchall()
+
+            logger.info(f"获取到群聊 {group_id} 今日消息 {len(messages)} 条")
+            return messages
+
+        except Exception as e:
+            logger.error(f"获取今日消息失败: {e}")
+            return []
+
+    def _format_messages(self, messages: List[Dict]) -> str:
+        """格式化消息为AI可理解的格式"""
+        formatted_lines = []
+        
+        for msg in messages:
+            create_time = msg['create_time']
+            if isinstance(create_time, datetime):
+                time_str = create_time.strftime("%H:%M:%S")
+            else:
+                time_str = str(create_time)
+            
+            nickname = msg.get('nickname') or msg['sender_wxid'][-8:]
+            content = msg['content'].replace('\n', '。').strip()
+            if len(content) > 200:
+                content = content[:200] + "..."
+            
+            formatted_line = f'[{time_str}] {{"{nickname}": "{content}"}}--end--'
+            formatted_lines.append(formatted_line)
+
+        return '\n'.join(formatted_lines)
+
+    async def _call_ai_api(self, formatted_messages: str, group_id: str, time_desc: str = "昨日") -> Optional[str]:
+        """调用AI API生成总结"""
+        try:
+            system_prompt = """你是一个中文的群聊总结的助手，你可以为一个微信的群聊记录，提取并总结每个时间段大家在重点讨论的话题内容。
+
+每一行代表一个人的发言，每一行的格式为： [time] {"nickname": "content"}--end--
+
+请帮我将给出的群聊内容总结成一个今日的群聊报告，包含不多于10个的话题的总结（如果还有更多话题，可以在后面简单补充）。每个话题包含以下内容：
+- 话题名(50字以内，带序号1️⃣2️⃣3️⃣，同时附带热度，以🔥数量表示）
+- 参与者(不超过5个人，将重复的人名去重)
+- 时间段(从几点到几点)
+- 过程(50到200字左右）
+- 评价(50字以下)
+- 分割线： ------------
+
+另外有以下要求：
+1. 每个话题结束使用 ------------ 分割
+2. 使用中文冒号
+3. 无需大标题
+4. 开始给出本群讨论风格的整体评价，例如活跃、太水、太黄、太暴力、话题不集中、无聊诸如此类"""
+
+            user_content = f"群聊记录如下:\n{formatted_messages}"
+
+            api_config = self.config["api"]
+            
+            payload = {
+                "model": api_config["model"],
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content}
+                ],
+                "max_tokens": api_config["max_tokens"],
+                "temperature": api_config.get("temperature", 0.7)
+            }
+
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_config['api_key']}"
+            }
+
+            timeout = aiohttp.ClientTimeout(total=api_config["timeout"])
+
+            proxy = None
+            proxy_config = self.config.get("proxy", {})
+            if proxy_config.get("enabled", False):
+                proxy_type = proxy_config.get("type", "http")
+                proxy_host = proxy_config.get("host", "127.0.0.1")
+                proxy_port = proxy_config.get("port", 7890)
+                proxy = f"{proxy_type}://{proxy_host}:{proxy_port}"
+
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    api_config["base_url"],
+                    json=payload,
+                    headers=headers,
+                    proxy=proxy
+                ) as resp:
+                    if resp.status != 200:
+                        error_text = await resp.text()
+                        logger.error(f"AI API 错误: {resp.status}, {error_text}")
+                        return None
+
+                    result = await resp.json()
+                    
+                    if "choices" not in result or not result["choices"]:
+                        logger.error("AI API 返回格式错误")
+                        return None
+
+                    content = result["choices"][0]["message"]["content"]
+                    return content.strip()
+
+        except Exception as e:
+            logger.error(f"调用AI API失败: {e}")
+            return None
+
+    async def _send_summary_as_chat_record(self, bot, group_id: str, summary: str, summary_type: str):
+        """将总结以聊天记录格式发送"""
+        try:
+            stats = await self._get_chat_stats(group_id, summary_type == "今日")
+            
+            header = f"📊 #{summary_type}群聊总结\n让我们一起来看看群友们都聊了什么有趣的话题吧~\n"
+            
+            if stats:
+                stats_text = f"\n📈 数据统计：\n• 发言人数：{stats['active_users']} 人\n• 消息总数：{stats['total_messages']} 条\n• 平均每人：{stats['avg_messages']:.1f} 条\n\n"
+            else:
+                stats_text = "\n"
+            
+            full_message = header + stats_text + summary
+            
+            # 直接使用聊天记录格式
+            await self._send_chat_records(bot, group_id, f"{summary_type}群聊总结", full_message)
+            logger.success(f"{summary_type}群聊总结已发送到 {group_id}")
+
+        except Exception as e:
+            logger.error(f"发送{summary_type}总结失败: {e}")
+
+    async def _generate_md_screenshot(self, group_id: str, summary_type: str, content: str) -> Optional[str]:
+        """生成MD文件并截图"""
+        try:
+            from PIL import Image, ImageDraw, ImageFont
+            
+            # 创建输出目录（插件文件夹内）
+            plugin_dir = Path(__file__).parent
+            output_dir = plugin_dir / "images"
+            output_dir.mkdir(exist_ok=True)
+            
+            # 清理表情符号
+            clean_content = content
+            emoji_replacements = {
+                '📊': '', '📈': '', '•': '·', '🔥': '', 
+                '1️⃣': '1.', '2️⃣': '2.', '3️⃣': '3.', '4️⃣': '4.', '5️⃣': '5.',
+                '❌': '×', '✅': '√'
+            }
+            for emoji, replacement in emoji_replacements.items():
+                clean_content = clean_content.replace(emoji, replacement)
+            
+            lines = clean_content.split('\n')
+            
+            # 图片设置
+            width = 800
+            padding = 30
+            line_height = 28
+            card_padding = 20
+            
+            # 计算足够的高度
+            estimated_height = len(lines) * line_height * 2 + 300  # 增加更多空间
+            img = Image.new('RGB', (width, estimated_height), '#f5f5f5')
+            draw = ImageDraw.Draw(img)
+            
+            # 字体设置
+            try:
+                title_font = ImageFont.truetype("msyhbd.ttc", 22)
+                header_font = ImageFont.truetype("msyhbd.ttc", 18)
+                content_font = ImageFont.truetype("msyh.ttc", 16)
+            except:
+                title_font = ImageFont.load_default()
+                header_font = ImageFont.load_default()
+                content_font = ImageFont.load_default()
+            
+            # 绘制顶部标题栏
+            header_height = 60
+            draw.rectangle([(0, 0), (width, header_height)], fill='#ffd700')
+            
+            # 标题文字
+            main_title = "群聊总结"
+            title_bbox = draw.textbbox((0, 0), main_title, font=title_font)
+            title_width = title_bbox[2] - title_bbox[0]
+            title_x = (width - title_width) // 2
+            draw.text((title_x, 18), main_title, fill='#333333', font=title_font)
+            
+            # 内容区域
+            y = header_height + padding
+            
+            for line in lines:
+                if not line.strip():
+                    y += line_height // 2
+                    continue
+                
+                # 去掉开头的表情符号标记
+                display_line = line.strip()
+                
+                if '总结' in line and line.startswith('#'):
+                    # 主标题 - 跳过，已在顶部显示
+                    continue
+                elif '数据统计' in line:
+                    # 数据统计卡片
+                    card_height = 120
+                    draw.rectangle([(padding, y), (width-padding, y+card_height)], 
+                                 fill='#e8f5e8', outline='#27ae60', width=2)
+                    draw.text((padding+card_padding, y+15), "数据统计", fill='#27ae60', font=header_font)
+                    y += 45
+                elif display_line.startswith(('·', '-')) and ('发言人数' in line or '消息总数' in line or '平均每人' in line):
+                    # 统计数据
+                    draw.text((padding+card_padding, y), display_line, fill='#333333', font=content_font)
+                    y += line_height
+                elif display_line.startswith(('1.', '2.', '3.', '4.', '5.')):
+                    # 话题标题卡片
+                    if y > header_height + padding + 50:  # 不是第一个卡片
+                        y += 15  # 卡片间距
+                    
+                    card_height = 40
+                    draw.rectangle([(padding, y), (width-padding, y+card_height)], 
+                                 fill='#e3f2fd', outline='#2196f3', width=2)
+                    draw.text((padding+card_padding, y+10), display_line, fill='#1976d2', font=header_font)
+                    y += card_height + 10
+                elif display_line.startswith('参与者:'):
+                    wrapped_lines = self._wrap_text(display_line, width-padding*2-card_padding*2, content_font, draw)
+                    for wrapped_line in wrapped_lines:
+                        draw.text((padding+card_padding, y), wrapped_line, fill='#666666', font=content_font)
+                        y += line_height
+                elif display_line.startswith('时间段:'):
+                    wrapped_lines = self._wrap_text(display_line, width-padding*2-card_padding*2, content_font, draw)
+                    for wrapped_line in wrapped_lines:
+                        draw.text((padding+card_padding, y), wrapped_line, fill='#666666', font=content_font)
+                        y += line_height
+                elif display_line.startswith('过程:'):
+                    wrapped_lines = self._wrap_text(display_line, width-padding*2-card_padding*2, content_font, draw)
+                    for wrapped_line in wrapped_lines:
+                        draw.text((padding+card_padding, y), wrapped_line, fill='#333333', font=content_font)
+                        y += line_height
+                elif display_line.startswith('评价:'):
+                    wrapped_lines = self._wrap_text(display_line, width-padding*2-card_padding*2, content_font, draw)
+                    for wrapped_line in wrapped_lines:
+                        draw.text((padding+card_padding, y), wrapped_line, fill='#666666', font=content_font)
+                        y += line_height
+                    y += 10  # 额外间距
+                elif '----' in line:
+                    # 分割线
+                    draw.line([(padding+20, y+5), (width-padding-20, y+5)], fill='#cccccc', width=1)
+                    y += 15
+                else:
+                    # 其他内容也进行换行处理
+                    wrapped_lines = self._wrap_text(display_line, width-padding*2-card_padding*2, content_font, draw)
+                    for wrapped_line in wrapped_lines:
+                        draw.text((padding+card_padding, y), wrapped_line, fill='#333333', font=content_font)
+                        y += line_height
+            
+            # 保存图片
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            group_short = group_id.split('@')[0][-8:]
+            image_path = output_dir / f"summary_{group_short}_{timestamp}.jpg"
+            
+            img.save(image_path, 'JPEG', quality=90)
+            logger.success(f"截图已生成: {image_path}")
+            return str(image_path)
+            
+        except ImportError:
+            logger.error("需要安装: pip install Pillow")
+            return None
+        except Exception as e:
+            logger.error(f"截图失败: {e}")
+            return None
+
+    def _wrap_text(self, text, max_width, font, draw):
+        """文本换行处理"""
+        words = text.split()
+        lines = []
+        current_line = ""
+        
+        for word in words:
+            test_line = current_line + (" " if current_line else "") + word
+            bbox = draw.textbbox((0, 0), test_line, font=font)
+            if bbox[2] - bbox[0] <= max_width:
+                current_line = test_line
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+        
+        if current_line:
+            lines.append(current_line)
+        
+        return lines if lines else [text]
+
+    async def _send_chat_records(self, bot, from_wxid: str, title: str, content: str):
+        """发送聊天记录格式消息"""
+        try:
+            import uuid
+            import time
+            import hashlib
+            import xml.etree.ElementTree as ET
+
+            is_group = from_wxid.endswith("@chatroom")
+            
+            max_length = 800
+            content_parts = []
+            
+            if len(content) <= max_length:
+                content_parts = [content]
+            else:
+                lines = content.split('\n')
+                current_part = ""
+                
+                for line in lines:
+                    if len(current_part + line + '\n') > max_length:
+                        if current_part:
+                            content_parts.append(current_part.strip())
+                            current_part = line + '\n'
+                        else:
+                            content_parts.append(line[:max_length])
+                            current_part = line[max_length:] + '\n'
+                    else:
+                        current_part += line + '\n'
+                
+                if current_part.strip():
+                    content_parts.append(current_part.strip())
+
+            recordinfo = ET.Element("recordinfo")
+            info_el = ET.SubElement(recordinfo, "info")
+            info_el.text = title
+            is_group_el = ET.SubElement(recordinfo, "isChatRoom")
+            is_group_el.text = "1" if is_group else "0"
+            datalist = ET.SubElement(recordinfo, "datalist")
+            datalist.set("count", str(len(content_parts)))
+            desc_el = ET.SubElement(recordinfo, "desc")
+            desc_el.text = title
+            fromscene_el = ET.SubElement(recordinfo, "fromscene")
+            fromscene_el.text = "3"
+
+            for i, part in enumerate(content_parts):
+                di = ET.SubElement(datalist, "dataitem")
+                di.set("datatype", "1")
+                di.set("dataid", uuid.uuid4().hex)
+                
+                src_local_id = str((int(time.time() * 1000) % 90000) + 10000)
+                new_msg_id = str(int(time.time() * 1000) + i)
+                create_time = str(int(time.time()) - len(content_parts) + i)
+                
+                ET.SubElement(di, "srcMsgLocalid").text = src_local_id
+                ET.SubElement(di, "sourcetime").text = time.strftime("%Y-%m-%d %H:%M", time.localtime(int(create_time)))
+                ET.SubElement(di, "fromnewmsgid").text = new_msg_id
+                ET.SubElement(di, "srcMsgCreateTime").text = create_time
+                ET.SubElement(di, "sourcename").text = "AI助手"
+                ET.SubElement(di, "sourceheadurl").text = ""
+                ET.SubElement(di, "datatitle").text = part
+                ET.SubElement(di, "datadesc").text = part
+                ET.SubElement(di, "datafmt").text = "text"
+                ET.SubElement(di, "ischatroom").text = "1" if is_group else "0"
+                
+                dataitemsource = ET.SubElement(di, "dataitemsource")
+                ET.SubElement(dataitemsource, "hashusername").text = hashlib.sha256(from_wxid.encode("utf-8")).hexdigest()
+
+            record_xml = ET.tostring(recordinfo, encoding="unicode")
+
+            appmsg_parts = [
+                "<appmsg appid=\"\" sdkver=\"0\">",
+                f"<title>{title}</title>",
+                f"<des>{title}</des>",
+                "<type>19</type>",
+                "<url>https://support.weixin.qq.com/cgi-bin/mmsupport-bin/readtemplate?t=page/favorite_record__w_unsupport</url>",
+                "<appattach><cdnthumbaeskey></cdnthumbaeskey><aeskey></aeskey></appattach>",
+                f"<recorditem><![CDATA[{record_xml}]]></recorditem>",
+                "<percent>0</percent>",
+                "</appmsg>"
+            ]
+            appmsg_xml = "".join(appmsg_parts)
+
+            await bot._send_data_async(11214, {"to_wxid": from_wxid, "content": appmsg_xml})
+            logger.success(f"已发送聊天记录: {title}")
+
+        except Exception as e:
+            logger.error(f"发送聊天记录失败: {e}")
+
+    async def _get_chat_stats(self, group_id: str, is_today: bool = False) -> Optional[Dict]:
+        """获取群聊统计信息"""
+        try:
+            if is_today:
+                today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+                tomorrow = today + timedelta(days=1)
+                start_time, end_time = today, tomorrow
+            else:
+                today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+                yesterday_start = today - timedelta(days=1)
+                start_time, end_time = yesterday_start, today
+
+            with self.get_db_connection() as conn:
+                with conn.cursor() as cursor:
+                    sql = """
+                    SELECT 
+                        COUNT(DISTINCT sender_wxid) as active_users,
+                        COUNT(*) as total_messages
+                    FROM messages 
+                    WHERE group_id = %s 
+                      AND is_group = 1 
+                      AND msg_type = 'text'
+                      AND create_time >= %s 
+                      AND create_time < %s
+                    """
+                    cursor.execute(sql, (group_id, start_time, end_time))
+                    result = cursor.fetchone()
+                    
+                    if result:
+                        active_users, total_messages = result
+                        avg_messages = total_messages / max(active_users, 1)
+                        
+                        return {
+                            "active_users": active_users,
+                            "total_messages": total_messages,
+                            "avg_messages": avg_messages
+                        }
+
+        except Exception as e:
+            logger.error(f"获取群聊统计失败: {e}")
+        
+        return None
+
+    def get_llm_tools(self) -> List[dict]:
+        """返回LLM工具定义，供AIChat插件调用"""
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": "generate_summary",
+                    "description": "生成群聊总结，可以选择今日或昨日的聊天记录",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "time_period": {
+                                "type": "string",
+                                "description": "时间段，可选值：'today'（今日）或'yesterday'（昨日）",
+                                "enum": ["today", "yesterday"],
+                                "default": "yesterday"
+                            }
+                        },
+                        "required": []
+                    }
+                }
+            }
+        ]
+
+    async def execute_llm_tool(self, tool_name: str, arguments: dict, bot, from_wxid: str) -> dict:
+        """执行LLM工具调用，供AIChat插件调用"""
+        try:
+            if self.config is None:
+                return {"success": False, "message": "群聊总结插件未初始化"}
+
+            if not self.config["behavior"]["enabled"]:
+                return {"success": False, "message": "群聊总结插件未启用"}
+
+            # 检查群聊权限
+            is_group = from_wxid.endswith("@chatroom")
+            if not is_group:
+                return {"success": False, "message": "群聊总结只能在群聊中使用"}
+
+            enabled_groups = self.config["behavior"]["enabled_groups"]
+            disabled_groups = self.config["behavior"]["disabled_groups"]
+
+            if from_wxid in disabled_groups or (enabled_groups and from_wxid not in enabled_groups):
+                return {"success": False, "message": "此群聊未启用总结功能"}
+
+            if tool_name == "generate_summary":
+                time_period = arguments.get("time_period", "yesterday")
+                is_today = time_period == "today"
+                summary_type = "今日" if is_today else "昨日"
+                
+                logger.info(f"LLM工具调用生成{summary_type}群聊总结: {from_wxid}")
+                await bot.send_text(from_wxid, f"🤖 正在生成{summary_type}群聊总结，请稍候...")
+
+                summary = await self._generate_summary(from_wxid, is_today)
+                if summary:
+                    await self._send_summary_as_chat_record(bot, from_wxid, summary, summary_type)
+                    return {"success": True, "message": f"{summary_type}群聊总结已生成并发送"}
+                else:
+                    await bot.send_text(from_wxid, f"❌ 生成{summary_type}总结失败，可能是聊天记录不足或AI服务异常")
+                    return {"success": False, "message": f"生成{summary_type}总结失败"}
+            else:
+                return None  # 不是本插件的工具，返回None让其他插件处理
+                
+        except Exception as e:
+            logger.error(f"LLM工具执行失败: {e}")
+            return {"success": False, "message": f"执行失败: {str(e)}"}