From 5d471440e6a32a4a8ef63e25b6a174f6a00196ee Mon Sep 17 00:00:00 2001 From: UnCLAS-Prommer Date: Sat, 19 Apr 2025 22:41:52 +0800 Subject: [PATCH 01/26] =?UTF-8?q?=E6=8B=86=E5=88=86=5Fexecute=5Frequest?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/PFC/reply_generator.py | 2 +- .../reasoning_chat/reasoning_chat.py | 2 +- src/plugins/models/utils_model_new.py | 1231 +++++++++++++++++ 3 files changed, 1233 insertions(+), 2 deletions(-) create mode 100644 src/plugins/models/utils_model_new.py diff --git a/src/plugins/PFC/reply_generator.py b/src/plugins/PFC/reply_generator.py index bb471900..a27abecd 100644 --- a/src/plugins/PFC/reply_generator.py +++ b/src/plugins/PFC/reply_generator.py @@ -151,7 +151,7 @@ class ReplyGenerator: return content except Exception as e: - logger.error(f"生成回复时出错: {e}") + logger.error(f"生成回复时出错: {str(e)}") return "抱歉，我现在有点混乱，让我重新思考一下..." async def check_reply(self, reply: str, goal: str, retry_count: int = 0) -> Tuple[bool, str, bool]: diff --git a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py index 5809e31d..46eeb79f 100644 --- a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py +++ b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py @@ -255,7 +255,7 @@ class ReasoningChat: info_catcher.catch_after_generate_response(timing_results["生成回复"]) except Exception as e: - logger.error(f"回复生成出现错误：str{e}") + logger.error(f"回复生成出现错误：{str(e)}") response_set = None if not response_set: diff --git a/src/plugins/models/utils_model_new.py b/src/plugins/models/utils_model_new.py new file mode 100644 index 00000000..8535476c --- /dev/null +++ b/src/plugins/models/utils_model_new.py @@ -0,0 +1,1231 @@ +import asyncio +import json +import re +from datetime import datetime +from typing import Tuple, Union, Dict, Any + +import aiohttp +from aiohttp.client import ClientResponse + +from src.common.logger import get_module_logger +import base64 +from PIL import Image +import io +import os +from ...common.database import db +from ...config.config import global_config + +logger = get_module_logger("model_utils") + + +class PayLoadTooLargeError(Exception): + """自定义异常类，用于处理请求体过大错误""" + + def __init__(self, message: str): + super().__init__(message) + self.message = message + + def __str__(self): + return "请求体过大，请尝试压缩图片或减少输入内容。" + + +class RequestAbortException(Exception): + """自定义异常类，用于处理请求中断异常""" + + def __init__(self, message: str, response: ClientResponse): + super().__init__(message) + self.message = message + self.response = response + + def __str__(self): + return self.message + + +class PermissionDeniedException(Exception): + """自定义异常类，用于处理访问拒绝的异常""" + + def __init__(self, message: str): + super().__init__(message) + self.message = message + + def __str__(self): + return self.message + + +# 常见Error Code Mapping +error_code_mapping = { + 400: "参数不正确", + 401: "API key 错误，认证失败，请检查/config/bot_config.toml和.env中的配置是否正确哦~", + 402: "账号余额不足", + 403: "需要实名,或余额不足", + 404: "Not Found", + 429: "请求过于频繁，请稍后再试", + 500: "服务器内部故障", + 503: "服务器负载过高", +} + + +class LLMRequest: + # 定义需要转换的模型列表，作为类变量避免重复 + MODELS_NEEDING_TRANSFORMATION = [ + "o3-mini", + "o1-mini", + "o1-preview", + "o1-2024-12-17", + "o1-preview-2024-09-12", + "o3-mini-2025-01-31", + "o1-mini-2024-09-12", + ] + + def __init__(self, model: dict, **kwargs): + # 将大写的配置键转换为小写并从config中获取实际值 + try: + self.api_key = os.environ[model["key"]] + self.base_url = os.environ[model["base_url"]] + except AttributeError as e: + logger.error(f"原始 model dict 信息：{model}") + logger.error(f"配置错误：找不到对应的配置项 - {str(e)}") + raise ValueError(f"配置错误：找不到对应的配置项 - {str(e)}") from e + self.model_name: str = model["name"] + self.params = kwargs + + self.stream = model.get("stream", False) + self.pri_in = model.get("pri_in", 0) + self.pri_out = model.get("pri_out", 0) + + # 获取数据库实例 + self._init_database() + + # 从 kwargs 中提取 request_type，如果没有提供则默认为 "default" + self.request_type = kwargs.pop("request_type", "default") + + @staticmethod + def _init_database(): + """初始化数据库集合""" + try: + # 创建llm_usage集合的索引 + db.llm_usage.create_index([("timestamp", 1)]) + db.llm_usage.create_index([("model_name", 1)]) + db.llm_usage.create_index([("user_id", 1)]) + db.llm_usage.create_index([("request_type", 1)]) + except Exception as e: + logger.error(f"创建数据库索引失败: {str(e)}") + + def _record_usage( + self, + prompt_tokens: int, + completion_tokens: int, + total_tokens: int, + user_id: str = "system", + request_type: str = None, + endpoint: str = "/chat/completions", + ): + """记录模型使用情况到数据库 + Args: + prompt_tokens: 输入token数 + completion_tokens: 输出token数 + total_tokens: 总token数 + user_id: 用户ID，默认为system + request_type: 请求类型(chat/embedding/image/topic/schedule) + endpoint: API端点 + """ + # 如果 request_type 为 None，则使用实例变量中的值 + if request_type is None: + request_type = self.request_type + + try: + usage_data = { + "model_name": self.model_name, + "user_id": user_id, + "request_type": request_type, + "endpoint": endpoint, + "prompt_tokens": prompt_tokens, + "completion_tokens": completion_tokens, + "total_tokens": total_tokens, + "cost": self._calculate_cost(prompt_tokens, completion_tokens), + "status": "success", + "timestamp": datetime.now(), + } + db.llm_usage.insert_one(usage_data) + logger.trace( + f"Token使用情况 - 模型: {self.model_name}, " + f"用户: {user_id}, 类型: {request_type}, " + f"提示词: {prompt_tokens}, 完成: {completion_tokens}, " + f"总计: {total_tokens}" + ) + except Exception as e: + logger.error(f"记录token使用情况失败: {str(e)}") + + def _calculate_cost(self, prompt_tokens: int, completion_tokens: int) -> float: + """计算API调用成本 + 使用模型的pri_in和pri_out价格计算输入和输出的成本 + + Args: + prompt_tokens: 输入token数量 + completion_tokens: 输出token数量 + + Returns: + float: 总成本（元） + """ + # 使用模型的pri_in和pri_out计算成本 + input_cost = (prompt_tokens / 1000000) * self.pri_in + output_cost = (completion_tokens / 1000000) * self.pri_out + return round(input_cost + output_cost, 6) + + ''' + async def _execute_request( + self, + endpoint: str, + prompt: str = None, + image_base64: str = None, + image_format: str = None, + payload: dict = None, + retry_policy: dict = None, + response_handler: callable = None, + user_id: str = "system", + request_type: str = None, + ): + """统一请求执行入口 + Args: + endpoint: API端点路径 (如 "chat/completions") + prompt: prompt文本 + image_base64: 图片的base64编码 + image_format: 图片格式 + payload: 请求体数据 + retry_policy: 自定义重试策略 + response_handler: 自定义响应处理器 + user_id: 用户ID + request_type: 请求类型 + """ + + if request_type is None: + request_type = self.request_type + + # 合并重试策略 + default_retry = { + "max_retries": 3, + "base_wait": 10, + "retry_codes": [429, 413, 500, 503], + "abort_codes": [400, 401, 402, 403], + } + policy = {**default_retry, **(retry_policy or {})} + + # 常见Error Code Mapping + error_code_mapping = { + 400: "参数不正确", + 401: "API key 错误，认证失败，请检查/config/bot_config.toml和.env中的配置是否正确哦~", + 402: "账号余额不足", + 403: "需要实名,或余额不足", + 404: "Not Found", + 429: "请求过于频繁，请稍后再试", + 500: "服务器内部故障", + 503: "服务器负载过高", + } + + api_url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" + # 判断是否为流式 + stream_mode = self.stream + # logger_msg = "进入流式输出模式，" if stream_mode else "" + # logger.debug(f"{logger_msg}发送请求到URL: {api_url}") + # logger.info(f"使用模型: {self.model_name}") + + # 构建请求体 + if image_base64: + payload = await self._build_payload(prompt, image_base64, image_format) + elif payload is None: + payload = await self._build_payload(prompt) + + # 流式输出标志 + # 先构建payload，再添加流式输出标志 + if stream_mode: + payload["stream"] = stream_mode + + for retry in range(policy["max_retries"]): + try: + # 使用上下文管理器处理会话 + headers = await self._build_headers() + # 似乎是openai流式必须要的东西,不过阿里云的qwq-plus加了这个没有影响 + if stream_mode: + headers["Accept"] = "text/event-stream" + + async with aiohttp.ClientSession() as session: + try: + async with session.post(api_url, headers=headers, json=payload) as response: + # 处理需要重试的状态码 + if response.status in policy["retry_codes"]: + wait_time = policy["base_wait"] * (2**retry) + logger.warning( + f"模型 {self.model_name} 错误码: {response.status}, 等待 {wait_time}秒后重试" + ) + if response.status == 413: + logger.warning("请求体过大，尝试压缩...") + image_base64 = compress_base64_image_by_scale(image_base64) + payload = await self._build_payload(prompt, image_base64, image_format) + elif response.status in [500, 503]: + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + raise RuntimeError("服务器负载过高，模型恢复失败QAQ") + else: + logger.warning(f"模型 {self.model_name} 请求限制(429)，等待{wait_time}秒后重试...") + + await asyncio.sleep(wait_time) + continue + elif response.status in policy["abort_codes"]: + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + # 尝试获取并记录服务器返回的详细错误信息 + try: + error_json = await response.json() + if error_json and isinstance(error_json, list) and len(error_json) > 0: + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj = error_item["error"] + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error( + f"服务器错误详情: 代码={error_code}, 状态={error_status}, " + f"消息={error_message}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + # 处理单个错误对象的情况 + error_obj = error_json.get("error", {}) + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error( + f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}" + ) + else: + # 记录原始错误响应内容 + logger.error(f"服务器错误响应: {error_json}") + except Exception as e: + logger.warning(f"无法解析服务器错误响应: {str(e)}") + + if response.status == 403: + # 只针对硅基流动的V3和R1进行降级处理 + if ( + self.model_name.startswith("Pro/deepseek-ai") + and self.base_url == "https://api.siliconflow.cn/v1/" + ): + old_model_name = self.model_name + self.model_name = self.model_name[4:] # 移除"Pro/"前缀 + logger.warning( + f"检测到403错误，模型从 {old_model_name} 降级为 {self.model_name}" + ) + + # 对全局配置进行更新 + if global_config.llm_normal.get("name") == old_model_name: + global_config.llm_normal["name"] = self.model_name + logger.warning(f"将全局配置中的 llm_normal 模型临时降级至{self.model_name}") + + if global_config.llm_reasoning.get("name") == old_model_name: + global_config.llm_reasoning["name"] = self.model_name + logger.warning( + f"将全局配置中的 llm_reasoning 模型临时降级至{self.model_name}" + ) + + # 更新payload中的模型名 + if payload and "model" in payload: + payload["model"] = self.model_name + + # 重新尝试请求 + retry -= 1 # 不计入重试次数 + continue + + raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(response.status)}") + + response.raise_for_status() + reasoning_content = "" + + # 将流式输出转化为非流式输出 + if stream_mode: + flag_delta_content_finished = False + accumulated_content = "" + usage = None # 初始化usage变量，避免未定义错误 + + async for line_bytes in response.content: + try: + line = line_bytes.decode("utf-8").strip() + if not line: + continue + if line.startswith("data:"): + data_str = line[5:].strip() + if data_str == "[DONE]": + break + try: + chunk = json.loads(data_str) + if flag_delta_content_finished: + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage # 获取token用量 + else: + delta = chunk["choices"][0]["delta"] + delta_content = delta.get("content") + if delta_content is None: + delta_content = "" + accumulated_content += delta_content + # 检测流式输出文本是否结束 + finish_reason = chunk["choices"][0].get("finish_reason") + if delta.get("reasoning_content", None): + reasoning_content += delta["reasoning_content"] + if finish_reason == "stop": + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage + break + # 部分平台在文本输出结束前不会返回token用量，此时需要再获取一次chunk + flag_delta_content_finished = True + + except Exception as e: + logger.exception(f"模型 {self.model_name} 解析流式输出错误: {str(e)}") + except GeneratorExit: + logger.warning("模型 {self.model_name} 流式输出被中断，正在清理资源...") + # 确保资源被正确清理 + await response.release() + # 返回已经累积的内容 + result = { + "choices": [ + { + "message": { + "content": accumulated_content, + "reasoning_content": reasoning_content, + # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 + } + } + ], + "usage": usage, + } + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + except Exception as e: + logger.error(f"模型 {self.model_name} 处理流式输出时发生错误: {str(e)}") + # 确保在发生错误时也能正确清理资源 + try: + await response.release() + except Exception as cleanup_error: + logger.error(f"清理资源时发生错误: {cleanup_error}") + # 返回已经累积的内容 + result = { + "choices": [ + { + "message": { + "content": accumulated_content, + "reasoning_content": reasoning_content, + # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 + } + } + ], + "usage": usage, + } + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + content = accumulated_content + think_match = re.search(r"(.*?)", content, re.DOTALL) + if think_match: + reasoning_content = think_match.group(1).strip() + content = re.sub(r".*?", "", content, flags=re.DOTALL).strip() + # 构造一个伪result以便调用自定义响应处理器或默认处理器 + result = { + "choices": [ + { + "message": { + "content": content, + "reasoning_content": reasoning_content, + # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 + } + } + ], + "usage": usage, + } + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + else: + result = await response.json() + # 使用自定义处理器或默认处理 + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + + except (aiohttp.ClientError, asyncio.TimeoutError) as e: + if retry < policy["max_retries"] - 1: + wait_time = policy["base_wait"] * (2**retry) + logger.error(f"模型 {self.model_name} 网络错误，等待{wait_time}秒后重试... 错误: {str(e)}") + await asyncio.sleep(wait_time) + continue + else: + logger.critical(f"模型 {self.model_name} 网络错误达到最大重试次数: {str(e)}") + raise RuntimeError(f"网络请求失败: {str(e)}") from e + except Exception as e: + logger.critical(f"模型 {self.model_name} 未预期的错误: {str(e)}") + raise RuntimeError(f"请求过程中发生错误: {str(e)}") from e + + except aiohttp.ClientResponseError as e: + # 处理aiohttp抛出的响应错误 + if retry < policy["max_retries"] - 1: + wait_time = policy["base_wait"] * (2**retry) + logger.error( + f"模型 {self.model_name} HTTP响应错误，等待{wait_time}秒后重试... 状态码: {e.status}, 错误: {e.message}" + ) + try: + if hasattr(e, "response") and e.response and hasattr(e.response, "text"): + error_text = await e.response.text() + try: + error_json = json.loads(error_text) + if isinstance(error_json, list) and len(error_json) > 0: + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj = error_item["error"] + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + error_obj = error_json.get("error", {}) + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + else: + logger.error(f"模型 {self.model_name} 服务器错误响应: {error_json}") + except (json.JSONDecodeError, TypeError) as json_err: + logger.warning( + f"模型 {self.model_name} 响应不是有效的JSON: {str(json_err)}, 原始内容: {error_text[:200]}" + ) + except (AttributeError, TypeError, ValueError) as parse_err: + logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") + + await asyncio.sleep(wait_time) + else: + logger.critical( + f"模型 {self.model_name} HTTP响应错误达到最大重试次数: 状态码: {e.status}, 错误: {e.message}" + ) + # 安全地检查和记录请求详情 + if ( + image_base64 + and payload + and isinstance(payload, dict) + and "messages" in payload + and len(payload["messages"]) > 0 + ): + if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: + content = payload["messages"][0]["content"] + if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: + payload["messages"][0]["content"][1]["image_url"]["url"] = ( + f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," + f"{image_base64[:10]}...{image_base64[-10:]}" + ) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {payload}") + raise RuntimeError(f"模型 {self.model_name} API请求失败: 状态码 {e.status}, {e.message}") from e + except Exception as e: + if retry < policy["max_retries"] - 1: + wait_time = policy["base_wait"] * (2**retry) + logger.error(f"模型 {self.model_name} 请求失败，等待{wait_time}秒后重试... 错误: {str(e)}") + await asyncio.sleep(wait_time) + else: + logger.critical(f"模型 {self.model_name} 请求失败: {str(e)}") + # 安全地检查和记录请求详情 + if ( + image_base64 + and payload + and isinstance(payload, dict) + and "messages" in payload + and len(payload["messages"]) > 0 + ): + if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: + content = payload["messages"][0]["content"] + if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: + payload["messages"][0]["content"][1]["image_url"]["url"] = ( + f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," + f"{image_base64[:10]}...{image_base64[-10:]}" + ) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {payload}") + raise RuntimeError(f"模型 {self.model_name} API请求失败: {str(e)}") from e + + logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") + raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") + ''' + + async def _prepare_request( + self, + endpoint: str, + prompt: str = None, + image_base64: str = None, + image_format: str = None, + payload: dict = None, + retry_policy: dict = None, + ) -> Dict[str, Any]: + """配置请求参数 + Args: + endpoint: API端点路径 (如 "chat/completions") + prompt: prompt文本 + image_base64: 图片的base64编码 + image_format: 图片格式 + payload: 请求体数据 + retry_policy: 自定义重试策略 + request_type: 请求类型 + """ + + # 合并重试策略 + default_retry = { + "max_retries": 3, + "base_wait": 10, + "retry_codes": [429, 413, 500, 503], + "abort_codes": [400, 401, 402, 403], + } + policy = {**default_retry, **(retry_policy or {})} + + api_url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" + + stream_mode = self.stream + + # 构建请求体 + if image_base64: + payload = await self._build_payload(prompt, image_base64, image_format) + elif payload is None: + payload = await self._build_payload(prompt) + + if stream_mode: + payload["stream"] = stream_mode + + return { + "policy": policy, + "payload": payload, + "api_url": api_url, + "stream_mode": stream_mode, + "image_base64": image_base64, # 保留必要的exception处理所需的原始数据 + "image_format": image_format, + "prompt": prompt + } + + async def _execute_request( + self, + endpoint: str, + prompt: str = None, + image_base64: str = None, + image_format: str = None, + payload: dict = None, + retry_policy: dict = None, + response_handler: callable = None, + user_id: str = "system", + request_type: str = None, + ): + """统一请求执行入口 + Args: + endpoint: API端点路径 (如 "chat/completions") + prompt: prompt文本 + image_base64: 图片的base64编码 + image_format: 图片格式 + payload: 请求体数据 + retry_policy: 自定义重试策略 + response_handler: 自定义响应处理器 + user_id: 用户ID + request_type: 请求类型 + """ + # 获取请求配置 + request_content = await self._prepare_request( + endpoint, prompt, image_base64, image_format, payload, retry_policy + ) + if request_type is None: + request_type = self.request_type + for retry in range(request_content["policy"]["max_retries"]): + try: + # 使用上下文管理器处理会话 + headers = await self._build_headers() + # 似乎是openai流式必须要的东西,不过阿里云的qwq-plus加了这个没有影响 + if request_content["stream_mode"]: + headers["Accept"] = "text/event-stream" + async with aiohttp.ClientSession() as session: + async with session.post( + request_content["api_url"], headers=headers, json=request_content["payload"] + ) as response: + handled_result = await self._handle_response( + response, request_content, retry, response_handler, user_id, request_type, endpoint + ) + return handled_result + except Exception as e: + handled_payload, count_delta = await self._handle_exception(e, retry, request_content) + retry += count_delta # 降级不计入重试次数 + if handled_payload: + # 如果降级成功，重新构建请求体 + request_content["payload"] = handled_payload + continue + + logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") + raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") + + async def _handle_response( + self, + response: ClientResponse, + request_content: Dict[str, Any], + retry_count: int, + response_handler: callable, + user_id, + request_type, + endpoint, + ) -> Union[Dict[str, Any], None]: + policy = request_content["policy"] + stream_mode = request_content["stream_mode"] + if response.status in policy["retry_codes"] or response.status in policy["abort_codes"]: + await self._handle_error_response(response, retry_count, policy) + return + + response.raise_for_status() + result = {} + if stream_mode: + # 将流式输出转化为非流式输出 + result = await self._handle_stream_output(response) + else: + result = await response.json() + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + + async def _handle_stream_output(self, response: ClientResponse) -> Dict[str, Any]: + flag_delta_content_finished = False + accumulated_content = "" + usage = None # 初始化usage变量，避免未定义错误 + reasoning_content = "" + content = "" + async for line_bytes in response.content: + try: + line = line_bytes.decode("utf-8").strip() + if not line: + continue + if line.startswith("data:"): + data_str = line[5:].strip() + if data_str == "[DONE]": + break + try: + chunk = json.loads(data_str) + if flag_delta_content_finished: + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage # 获取token用量 + else: + delta = chunk["choices"][0]["delta"] + delta_content = delta.get("content") + if delta_content is None: + delta_content = "" + accumulated_content += delta_content + # 检测流式输出文本是否结束 + finish_reason = chunk["choices"][0].get("finish_reason") + if delta.get("reasoning_content", None): + reasoning_content += delta["reasoning_content"] + if finish_reason == "stop": + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage + break + # 部分平台在文本输出结束前不会返回token用量，此时需要再获取一次chunk + flag_delta_content_finished = True + except Exception as e: + logger.exception(f"模型 {self.model_name} 解析流式输出错误: {str(e)}") + except Exception as e: + if isinstance(e, GeneratorExit): + log_content = f"模型 {self.model_name} 流式输出被中断，正在清理资源..." + else: + log_content = f"模型 {self.model_name} 处理流式输出时发生错误: {str(e)}" + logger.warning(log_content) + # 确保资源被正确清理 + try: + await response.release() + except Exception as cleanup_error: + logger.error(f"清理资源时发生错误: {cleanup_error}") + # 返回已经累积的内容 + content = accumulated_content + if not content: + content = accumulated_content + think_match = re.search(r"(.*?)", content, re.DOTALL) + if think_match: + reasoning_content = think_match.group(1).strip() + content = re.sub(r".*?", "", content, flags=re.DOTALL).strip() + result = { + "choices": [ + { + "message": { + "content": content, + "reasoning_content": reasoning_content, + # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 + } + } + ], + "usage": usage, + } + return result + + async def _handle_error_response( + self, response: ClientResponse, retry_count: int, policy: Dict[str, Any] + ) -> Union[Dict[str, any]]: + if response.status in policy["retry_codes"]: + wait_time = policy["base_wait"] * (2**retry_count) + logger.warning(f"模型 {self.model_name} 错误码: {response.status}, 等待 {wait_time}秒后重试") + if response.status == 413: + logger.warning("请求体过大，尝试压缩...") + raise PayLoadTooLargeError("请求体过大") + elif response.status in [500, 503]: + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + raise RuntimeError("服务器负载过高，模型恢复失败QAQ") + else: + logger.warning(f"模型 {self.model_name} 请求限制(429)，等待{wait_time}秒后重试...") + raise RuntimeError("请求限制(429)") + elif response.status in policy["abort_codes"]: + if response.status != 403: + raise RequestAbortException("请求出现错误，中断处理", response) + else: + raise PermissionDeniedException("模型禁止访问") + + async def _handle_exception( + self, exception, retry_count: int, request_content: Dict[str, Any] + ) -> Union[Tuple[Dict[str, Any], int], Tuple[None, int]]: + policy = request_content["policy"] + payload = request_content["payload"] + keep_request = False + if retry_count < policy["max_retries"] - 1: + wait_time = policy["base_wait"] * (2**retry_count) + keep_request = True + if isinstance(exception, RequestAbortException): + response = exception.response + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + # 尝试获取并记录服务器返回的详细错误信息 + try: + error_json = await response.json() + if error_json and isinstance(error_json, list) and len(error_json) > 0: + # 处理多个错误的情况 + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj: dict = error_item["error"] + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error( + f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + # 处理单个错误对象的情况 + error_obj = error_json.get("error", {}) + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error(f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}") + else: + # 记录原始错误响应内容 + logger.error(f"服务器错误响应: {error_json}") + except Exception as e: + logger.warning(f"无法解析服务器错误响应: {str(e)}") + raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(response.status)}") + + elif isinstance(exception, PermissionDeniedException): + # 只针对硅基流动的V3和R1进行降级处理 + if self.model_name.startswith("Pro/deepseek-ai") and self.base_url == "https://api.siliconflow.cn/v1/": + old_model_name = self.model_name + self.model_name = self.model_name[4:] # 移除"Pro/"前缀 + logger.warning(f"检测到403错误，模型从 {old_model_name} 降级为 {self.model_name}") + + # 对全局配置进行更新 + if global_config.llm_normal.get("name") == old_model_name: + global_config.llm_normal["name"] = self.model_name + logger.warning(f"将全局配置中的 llm_normal 模型临时降级至{self.model_name}") + if global_config.llm_reasoning.get("name") == old_model_name: + global_config.llm_reasoning["name"] = self.model_name + logger.warning(f"将全局配置中的 llm_reasoning 模型临时降级至{self.model_name}") + + if payload and "model" in payload: + payload["model"] = self.model_name + + await asyncio.sleep(wait_time) + return payload, -1 + raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(403)}") + + elif isinstance(exception, PayLoadTooLargeError): + if keep_request: + image_base64 = request_content["image_base64"] + compressed_image_base64 = compress_base64_image_by_scale(image_base64) + new_payload = await self._build_payload(request_content["prompt"], compressed_image_base64, request_content["image_format"]) + return new_payload, 0 + else: + return None, 0 + + elif isinstance(exception, aiohttp.ClientError) or isinstance(exception, asyncio.TimeoutError): + if keep_request: + logger.error(f"模型 {self.model_name} 网络错误，等待{wait_time}秒后重试... 错误: {str(exception)}") + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical(f"模型 {self.model_name} 网络错误达到最大重试次数: {str(exception)}") + raise RuntimeError(f"网络请求失败: {str(exception)}") + + elif isinstance(exception, aiohttp.ClientResponseError): + # 处理aiohttp抛出的，除了policy中的status的响应错误 + if keep_request: + logger.error( + f"模型 {self.model_name} HTTP响应错误，等待{wait_time}秒后重试... 状态码: {exception.status}, 错误: {exception.message}" + ) + try: + error_text = await exception.response.text() + error_json = json.loads(error_text) + if isinstance(error_json, list) and len(error_json) > 0: + # 处理多个错误的情况 + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj = error_item["error"] + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + error_obj = error_json.get("error", {}) + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + else: + logger.error(f"模型 {self.model_name} 服务器错误响应: {error_json}") + except (json.JSONDecodeError, TypeError) as json_err: + logger.warning( + f"模型 {self.model_name} 响应不是有效的JSON: {str(json_err)}, 原始内容: {error_text[:200]}" + ) + except Exception as parse_err: + logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") + + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical( + f"模型 {self.model_name} HTTP响应错误达到最大重试次数: 状态码: {exception.status}, 错误: {exception.message}" + ) + # 安全地检查和记录请求详情 + handled_payload = await self._safely_record(request_content, payload) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") + raise RuntimeError( + f"模型 {self.model_name} API请求失败: 状态码 {exception.status}, {exception.message}" + ) + + else: + if keep_request: + logger.error(f"模型 {self.model_name} 请求失败，等待{wait_time}秒后重试... 错误: {str(exception)}") + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical(f"模型 {self.model_name} 请求失败: {str(exception)}") + # 安全地检查和记录请求详情 + handled_payload = await self._safely_record(request_content, payload) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") + raise RuntimeError(f"模型 {self.model_name} API请求失败: {str(exception)}") + + async def _safely_record(self, request_content: Dict[str, Any], payload: Dict[str, Any]): + image_base64: str = request_content.get("image_base64") + image_format: str = request_content.get("image_format") + if ( + image_base64 + and payload + and isinstance(payload, dict) + and "messages" in payload + and len(payload["messages"]) > 0 + ): + if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: + content = payload["messages"][0]["content"] + if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: + payload["messages"][0]["content"][1]["image_url"]["url"] = ( + f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," + f"{image_base64[:10]}...{image_base64[-10:]}" + ) + # if isinstance(content, str) and len(content) > 100: + # payload["messages"][0]["content"] = content[:100] + return payload + + async def _transform_parameters(self, params: dict) -> dict: + """ + 根据模型名称转换参数： + - 对于需要转换的OpenAI CoT系列模型（例如 "o3-mini"），删除 'temperature' 参数， + 并将 'max_tokens' 重命名为 'max_completion_tokens' + """ + # 复制一份参数，避免直接修改原始数据 + new_params = dict(params) + + if self.model_name.lower() in self.MODELS_NEEDING_TRANSFORMATION: + # 删除 'temperature' 参数（如果存在） + new_params.pop("temperature", None) + # 如果存在 'max_tokens'，则重命名为 'max_completion_tokens' + if "max_tokens" in new_params: + new_params["max_completion_tokens"] = new_params.pop("max_tokens") + return new_params + + async def _build_payload(self, prompt: str, image_base64: str = None, image_format: str = None) -> dict: + """构建请求体""" + # 复制一份参数，避免直接修改 self.params + params_copy = await self._transform_parameters(self.params) + if image_base64: + payload = { + "model": self.model_name, + "messages": [ + { + "role": "user", + "content": [ + {"type": "text", "text": prompt}, + { + "type": "image_url", + "image_url": {"url": f"data:image/{image_format.lower()};base64,{image_base64}"}, + }, + ], + } + ], + "max_tokens": global_config.max_response_length, + **params_copy, + } + else: + payload = { + "model": self.model_name, + "messages": [{"role": "user", "content": prompt}], + "max_tokens": global_config.max_response_length, + **params_copy, + } + # 如果 payload 中依然存在 max_tokens 且需要转换，在这里进行再次检查 + if self.model_name.lower() in self.MODELS_NEEDING_TRANSFORMATION and "max_tokens" in payload: + payload["max_completion_tokens"] = payload.pop("max_tokens") + return payload + + def _default_response_handler( + self, result: dict, user_id: str = "system", request_type: str = None, endpoint: str = "/chat/completions" + ) -> Tuple: + """默认响应解析""" + if "choices" in result and result["choices"]: + message = result["choices"][0]["message"] + content = message.get("content", "") + content, reasoning = self._extract_reasoning(content) + reasoning_content = message.get("model_extra", {}).get("reasoning_content", "") + if not reasoning_content: + reasoning_content = message.get("reasoning_content", "") + if not reasoning_content: + reasoning_content = reasoning + + # 提取工具调用信息 + tool_calls = message.get("tool_calls", None) + + # 记录token使用情况 + usage = result.get("usage", {}) + if usage: + prompt_tokens = usage.get("prompt_tokens", 0) + completion_tokens = usage.get("completion_tokens", 0) + total_tokens = usage.get("total_tokens", 0) + self._record_usage( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + total_tokens=total_tokens, + user_id=user_id, + request_type=request_type if request_type is not None else self.request_type, + endpoint=endpoint, + ) + + # 只有当tool_calls存在且不为空时才返回 + if tool_calls: + return content, reasoning_content, tool_calls + else: + return content, reasoning_content + + return "没有返回结果", "" + + @staticmethod + def _extract_reasoning(content: str) -> Tuple[str, str]: + """CoT思维链提取""" + match = re.search(r"(?:)?(.*?)", content, re.DOTALL) + content = re.sub(r"(?:)?.*?", "", content, flags=re.DOTALL, count=1).strip() + if match: + reasoning = match.group(1).strip() + else: + reasoning = "" + return content, reasoning + + async def _build_headers(self, no_key: bool = False) -> dict: + """构建请求头""" + if no_key: + return {"Authorization": "Bearer **********", "Content-Type": "application/json"} + else: + return {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"} + # 防止小朋友们截图自己的key + + async def generate_response(self, prompt: str) -> Tuple: + """根据输入的提示生成模型的异步响应""" + + response = await self._execute_request(endpoint="/chat/completions", prompt=prompt) + # 根据返回值的长度决定怎么处理 + if len(response) == 3: + content, reasoning_content, tool_calls = response + return content, reasoning_content, self.model_name, tool_calls + else: + content, reasoning_content = response + return content, reasoning_content, self.model_name + + async def generate_response_for_image(self, prompt: str, image_base64: str, image_format: str) -> Tuple: + """根据输入的提示和图片生成模型的异步响应""" + + response = await self._execute_request( + endpoint="/chat/completions", prompt=prompt, image_base64=image_base64, image_format=image_format + ) + # 根据返回值的长度决定怎么处理 + if len(response) == 3: + content, reasoning_content, tool_calls = response + return content, reasoning_content, tool_calls + else: + content, reasoning_content = response + return content, reasoning_content + + async def generate_response_async(self, prompt: str, **kwargs) -> Union[str, Tuple]: + """异步方式根据输入的提示生成模型的响应""" + # 构建请求体 + data = { + "model": self.model_name, + "messages": [{"role": "user", "content": prompt}], + "max_tokens": global_config.max_response_length, + **self.params, + **kwargs, + } + + response = await self._execute_request(endpoint="/chat/completions", payload=data, prompt=prompt) + # 原样返回响应，不做处理 + return response + + async def get_embedding(self, text: str) -> Union[list, None]: + """异步方法：获取文本的embedding向量 + + Args: + text: 需要获取embedding的文本 + + Returns: + list: embedding向量，如果失败则返回None + """ + + if len(text) < 1: + logger.debug("该消息没有长度，不再发送获取embedding向量的请求") + return None + + def embedding_handler(result): + """处理响应""" + if "data" in result and len(result["data"]) > 0: + # 提取 token 使用信息 + usage = result.get("usage", {}) + if usage: + prompt_tokens = usage.get("prompt_tokens", 0) + completion_tokens = usage.get("completion_tokens", 0) + total_tokens = usage.get("total_tokens", 0) + # 记录 token 使用情况 + self._record_usage( + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + total_tokens=total_tokens, + user_id="system", # 可以根据需要修改 user_id + # request_type="embedding", # 请求类型为 embedding + request_type=self.request_type, # 请求类型为 text + endpoint="/embeddings", # API 端点 + ) + return result["data"][0].get("embedding", None) + return result["data"][0].get("embedding", None) + return None + + embedding = await self._execute_request( + endpoint="/embeddings", + prompt=text, + payload={"model": self.model_name, "input": text, "encoding_format": "float"}, + retry_policy={"max_retries": 2, "base_wait": 6}, + response_handler=embedding_handler, + ) + return embedding + + +def compress_base64_image_by_scale(base64_data: str, target_size: int = 0.8 * 1024 * 1024) -> str: + """压缩base64格式的图片到指定大小 + Args: + base64_data: base64编码的图片数据 + target_size: 目标文件大小（字节），默认0.8MB + Returns: + str: 压缩后的base64图片数据 + """ + try: + # 将base64转换为字节数据 + image_data = base64.b64decode(base64_data) + + # 如果已经小于目标大小，直接返回原图 + if len(image_data) <= 2 * 1024 * 1024: + return base64_data + + # 将字节数据转换为图片对象 + img = Image.open(io.BytesIO(image_data)) + + # 获取原始尺寸 + original_width, original_height = img.size + + # 计算缩放比例 + scale = min(1.0, (target_size / len(image_data)) ** 0.5) + + # 计算新的尺寸 + new_width = int(original_width * scale) + new_height = int(original_height * scale) + + # 创建内存缓冲区 + output_buffer = io.BytesIO() + + # 如果是GIF，处理所有帧 + if getattr(img, "is_animated", False): + frames = [] + for frame_idx in range(img.n_frames): + img.seek(frame_idx) + new_frame = img.copy() + new_frame = new_frame.resize((new_width // 2, new_height // 2), Image.Resampling.LANCZOS) # 动图折上折 + frames.append(new_frame) + + # 保存到缓冲区 + frames[0].save( + output_buffer, + format="GIF", + save_all=True, + append_images=frames[1:], + optimize=True, + duration=img.info.get("duration", 100), + loop=img.info.get("loop", 0), + ) + else: + # 处理静态图片 + resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS) + + # 保存到缓冲区，保持原始格式 + if img.format == "PNG" and img.mode in ("RGBA", "LA"): + resized_img.save(output_buffer, format="PNG", optimize=True) + else: + resized_img.save(output_buffer, format="JPEG", quality=95, optimize=True) + + # 获取压缩后的数据并转换为base64 + compressed_data = output_buffer.getvalue() + logger.success(f"压缩图片: {original_width}x{original_height} -> {new_width}x{new_height}") + logger.info(f"压缩前大小: {len(image_data) / 1024:.1f}KB, 压缩后大小: {len(compressed_data) / 1024:.1f}KB") + + return base64.b64encode(compressed_data).decode("utf-8") + + except Exception as e: + logger.error(f"压缩图片失败: {str(e)}") + import traceback + + logger.error(traceback.format_exc()) + return base64_data From e6d770383662bd507dac7d030e792d1cda1d951b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 19 Apr 2025 14:42:27 +0000 Subject: [PATCH 02/26] =?UTF-8?q?=F0=9F=A4=96=20=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=20[skip=20ci]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/models/utils_model_new.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/plugins/models/utils_model_new.py b/src/plugins/models/utils_model_new.py index 8535476c..1faebc3e 100644 --- a/src/plugins/models/utils_model_new.py +++ b/src/plugins/models/utils_model_new.py @@ -610,7 +610,7 @@ class LLMRequest: "stream_mode": stream_mode, "image_base64": image_base64, # 保留必要的exception处理所需的原始数据 "image_format": image_format, - "prompt": prompt + "prompt": prompt, } async def _execute_request( @@ -862,7 +862,9 @@ class LLMRequest: if keep_request: image_base64 = request_content["image_base64"] compressed_image_base64 = compress_base64_image_by_scale(image_base64) - new_payload = await self._build_payload(request_content["prompt"], compressed_image_base64, request_content["image_format"]) + new_payload = await self._build_payload( + request_content["prompt"], compressed_image_base64, request_content["image_format"] + ) return new_payload, 0 else: return None, 0 @@ -910,7 +912,7 @@ class LLMRequest: ) except Exception as parse_err: logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") - + await asyncio.sleep(wait_time) return None, 0 else: From 46a5b01a1355c7ecfd819dab19b2c30b12e37d12 Mon Sep 17 00:00:00 2001 From: UnCLAS-Prommer Date: Sat, 19 Apr 2025 22:48:30 +0800 Subject: [PATCH 03/26] =?UTF-8?q?=E6=8B=86=E5=88=86=5Fexecute=5Frequest?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/models/utils_model.py | 455 ++++++++- src/plugins/models/utils_model_new.py | 1233 ------------------------- 2 files changed, 452 insertions(+), 1236 deletions(-) delete mode 100644 src/plugins/models/utils_model_new.py diff --git a/src/plugins/models/utils_model.py b/src/plugins/models/utils_model.py index 7930a035..1faebc3e 100644 --- a/src/plugins/models/utils_model.py +++ b/src/plugins/models/utils_model.py @@ -2,9 +2,11 @@ import asyncio import json import re from datetime import datetime -from typing import Tuple, Union +from typing import Tuple, Union, Dict, Any import aiohttp +from aiohttp.client import ClientResponse + from src.common.logger import get_module_logger import base64 from PIL import Image @@ -16,6 +18,53 @@ from ...config.config import global_config logger = get_module_logger("model_utils") +class PayLoadTooLargeError(Exception): + """自定义异常类，用于处理请求体过大错误""" + + def __init__(self, message: str): + super().__init__(message) + self.message = message + + def __str__(self): + return "请求体过大，请尝试压缩图片或减少输入内容。" + + +class RequestAbortException(Exception): + """自定义异常类，用于处理请求中断异常""" + + def __init__(self, message: str, response: ClientResponse): + super().__init__(message) + self.message = message + self.response = response + + def __str__(self): + return self.message + + +class PermissionDeniedException(Exception): + """自定义异常类，用于处理访问拒绝的异常""" + + def __init__(self, message: str): + super().__init__(message) + self.message = message + + def __str__(self): + return self.message + + +# 常见Error Code Mapping +error_code_mapping = { + 400: "参数不正确", + 401: "API key 错误，认证失败，请检查/config/bot_config.toml和.env中的配置是否正确哦~", + 402: "账号余额不足", + 403: "需要实名,或余额不足", + 404: "Not Found", + 429: "请求过于频繁，请稍后再试", + 500: "服务器内部故障", + 503: "服务器负载过高", +} + + class LLMRequest: # 定义需要转换的模型列表，作为类变量避免重复 MODELS_NEEDING_TRANSFORMATION = [ @@ -28,7 +77,7 @@ class LLMRequest: "o1-mini-2024-09-12", ] - def __init__(self, model, **kwargs): + def __init__(self, model: dict, **kwargs): # 将大写的配置键转换为小写并从config中获取实际值 try: self.api_key = os.environ[model["key"]] @@ -37,7 +86,7 @@ class LLMRequest: logger.error(f"原始 model dict 信息：{model}") logger.error(f"配置错误：找不到对应的配置项 - {str(e)}") raise ValueError(f"配置错误：找不到对应的配置项 - {str(e)}") from e - self.model_name = model["name"] + self.model_name: str = model["name"] self.params = kwargs self.stream = model.get("stream", False) @@ -123,6 +172,7 @@ class LLMRequest: output_cost = (completion_tokens / 1000000) * self.pri_out return round(input_cost + output_cost, 6) + ''' async def _execute_request( self, endpoint: str, @@ -509,6 +559,405 @@ class LLMRequest: logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") + ''' + + async def _prepare_request( + self, + endpoint: str, + prompt: str = None, + image_base64: str = None, + image_format: str = None, + payload: dict = None, + retry_policy: dict = None, + ) -> Dict[str, Any]: + """配置请求参数 + Args: + endpoint: API端点路径 (如 "chat/completions") + prompt: prompt文本 + image_base64: 图片的base64编码 + image_format: 图片格式 + payload: 请求体数据 + retry_policy: 自定义重试策略 + request_type: 请求类型 + """ + + # 合并重试策略 + default_retry = { + "max_retries": 3, + "base_wait": 10, + "retry_codes": [429, 413, 500, 503], + "abort_codes": [400, 401, 402, 403], + } + policy = {**default_retry, **(retry_policy or {})} + + api_url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" + + stream_mode = self.stream + + # 构建请求体 + if image_base64: + payload = await self._build_payload(prompt, image_base64, image_format) + elif payload is None: + payload = await self._build_payload(prompt) + + if stream_mode: + payload["stream"] = stream_mode + + return { + "policy": policy, + "payload": payload, + "api_url": api_url, + "stream_mode": stream_mode, + "image_base64": image_base64, # 保留必要的exception处理所需的原始数据 + "image_format": image_format, + "prompt": prompt, + } + + async def _execute_request( + self, + endpoint: str, + prompt: str = None, + image_base64: str = None, + image_format: str = None, + payload: dict = None, + retry_policy: dict = None, + response_handler: callable = None, + user_id: str = "system", + request_type: str = None, + ): + """统一请求执行入口 + Args: + endpoint: API端点路径 (如 "chat/completions") + prompt: prompt文本 + image_base64: 图片的base64编码 + image_format: 图片格式 + payload: 请求体数据 + retry_policy: 自定义重试策略 + response_handler: 自定义响应处理器 + user_id: 用户ID + request_type: 请求类型 + """ + # 获取请求配置 + request_content = await self._prepare_request( + endpoint, prompt, image_base64, image_format, payload, retry_policy + ) + if request_type is None: + request_type = self.request_type + for retry in range(request_content["policy"]["max_retries"]): + try: + # 使用上下文管理器处理会话 + headers = await self._build_headers() + # 似乎是openai流式必须要的东西,不过阿里云的qwq-plus加了这个没有影响 + if request_content["stream_mode"]: + headers["Accept"] = "text/event-stream" + async with aiohttp.ClientSession() as session: + async with session.post( + request_content["api_url"], headers=headers, json=request_content["payload"] + ) as response: + handled_result = await self._handle_response( + response, request_content, retry, response_handler, user_id, request_type, endpoint + ) + return handled_result + except Exception as e: + handled_payload, count_delta = await self._handle_exception(e, retry, request_content) + retry += count_delta # 降级不计入重试次数 + if handled_payload: + # 如果降级成功，重新构建请求体 + request_content["payload"] = handled_payload + continue + + logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") + raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") + + async def _handle_response( + self, + response: ClientResponse, + request_content: Dict[str, Any], + retry_count: int, + response_handler: callable, + user_id, + request_type, + endpoint, + ) -> Union[Dict[str, Any], None]: + policy = request_content["policy"] + stream_mode = request_content["stream_mode"] + if response.status in policy["retry_codes"] or response.status in policy["abort_codes"]: + await self._handle_error_response(response, retry_count, policy) + return + + response.raise_for_status() + result = {} + if stream_mode: + # 将流式输出转化为非流式输出 + result = await self._handle_stream_output(response) + else: + result = await response.json() + return ( + response_handler(result) + if response_handler + else self._default_response_handler(result, user_id, request_type, endpoint) + ) + + async def _handle_stream_output(self, response: ClientResponse) -> Dict[str, Any]: + flag_delta_content_finished = False + accumulated_content = "" + usage = None # 初始化usage变量，避免未定义错误 + reasoning_content = "" + content = "" + async for line_bytes in response.content: + try: + line = line_bytes.decode("utf-8").strip() + if not line: + continue + if line.startswith("data:"): + data_str = line[5:].strip() + if data_str == "[DONE]": + break + try: + chunk = json.loads(data_str) + if flag_delta_content_finished: + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage # 获取token用量 + else: + delta = chunk["choices"][0]["delta"] + delta_content = delta.get("content") + if delta_content is None: + delta_content = "" + accumulated_content += delta_content + # 检测流式输出文本是否结束 + finish_reason = chunk["choices"][0].get("finish_reason") + if delta.get("reasoning_content", None): + reasoning_content += delta["reasoning_content"] + if finish_reason == "stop": + chunk_usage = chunk.get("usage", None) + if chunk_usage: + usage = chunk_usage + break + # 部分平台在文本输出结束前不会返回token用量，此时需要再获取一次chunk + flag_delta_content_finished = True + except Exception as e: + logger.exception(f"模型 {self.model_name} 解析流式输出错误: {str(e)}") + except Exception as e: + if isinstance(e, GeneratorExit): + log_content = f"模型 {self.model_name} 流式输出被中断，正在清理资源..." + else: + log_content = f"模型 {self.model_name} 处理流式输出时发生错误: {str(e)}" + logger.warning(log_content) + # 确保资源被正确清理 + try: + await response.release() + except Exception as cleanup_error: + logger.error(f"清理资源时发生错误: {cleanup_error}") + # 返回已经累积的内容 + content = accumulated_content + if not content: + content = accumulated_content + think_match = re.search(r"(.*?)", content, re.DOTALL) + if think_match: + reasoning_content = think_match.group(1).strip() + content = re.sub(r".*?", "", content, flags=re.DOTALL).strip() + result = { + "choices": [ + { + "message": { + "content": content, + "reasoning_content": reasoning_content, + # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 + } + } + ], + "usage": usage, + } + return result + + async def _handle_error_response( + self, response: ClientResponse, retry_count: int, policy: Dict[str, Any] + ) -> Union[Dict[str, any]]: + if response.status in policy["retry_codes"]: + wait_time = policy["base_wait"] * (2**retry_count) + logger.warning(f"模型 {self.model_name} 错误码: {response.status}, 等待 {wait_time}秒后重试") + if response.status == 413: + logger.warning("请求体过大，尝试压缩...") + raise PayLoadTooLargeError("请求体过大") + elif response.status in [500, 503]: + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + raise RuntimeError("服务器负载过高，模型恢复失败QAQ") + else: + logger.warning(f"模型 {self.model_name} 请求限制(429)，等待{wait_time}秒后重试...") + raise RuntimeError("请求限制(429)") + elif response.status in policy["abort_codes"]: + if response.status != 403: + raise RequestAbortException("请求出现错误，中断处理", response) + else: + raise PermissionDeniedException("模型禁止访问") + + async def _handle_exception( + self, exception, retry_count: int, request_content: Dict[str, Any] + ) -> Union[Tuple[Dict[str, Any], int], Tuple[None, int]]: + policy = request_content["policy"] + payload = request_content["payload"] + keep_request = False + if retry_count < policy["max_retries"] - 1: + wait_time = policy["base_wait"] * (2**retry_count) + keep_request = True + if isinstance(exception, RequestAbortException): + response = exception.response + logger.error( + f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" + ) + # 尝试获取并记录服务器返回的详细错误信息 + try: + error_json = await response.json() + if error_json and isinstance(error_json, list) and len(error_json) > 0: + # 处理多个错误的情况 + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj: dict = error_item["error"] + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error( + f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + # 处理单个错误对象的情况 + error_obj = error_json.get("error", {}) + error_code = error_obj.get("code") + error_message = error_obj.get("message") + error_status = error_obj.get("status") + logger.error(f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}") + else: + # 记录原始错误响应内容 + logger.error(f"服务器错误响应: {error_json}") + except Exception as e: + logger.warning(f"无法解析服务器错误响应: {str(e)}") + raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(response.status)}") + + elif isinstance(exception, PermissionDeniedException): + # 只针对硅基流动的V3和R1进行降级处理 + if self.model_name.startswith("Pro/deepseek-ai") and self.base_url == "https://api.siliconflow.cn/v1/": + old_model_name = self.model_name + self.model_name = self.model_name[4:] # 移除"Pro/"前缀 + logger.warning(f"检测到403错误，模型从 {old_model_name} 降级为 {self.model_name}") + + # 对全局配置进行更新 + if global_config.llm_normal.get("name") == old_model_name: + global_config.llm_normal["name"] = self.model_name + logger.warning(f"将全局配置中的 llm_normal 模型临时降级至{self.model_name}") + if global_config.llm_reasoning.get("name") == old_model_name: + global_config.llm_reasoning["name"] = self.model_name + logger.warning(f"将全局配置中的 llm_reasoning 模型临时降级至{self.model_name}") + + if payload and "model" in payload: + payload["model"] = self.model_name + + await asyncio.sleep(wait_time) + return payload, -1 + raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(403)}") + + elif isinstance(exception, PayLoadTooLargeError): + if keep_request: + image_base64 = request_content["image_base64"] + compressed_image_base64 = compress_base64_image_by_scale(image_base64) + new_payload = await self._build_payload( + request_content["prompt"], compressed_image_base64, request_content["image_format"] + ) + return new_payload, 0 + else: + return None, 0 + + elif isinstance(exception, aiohttp.ClientError) or isinstance(exception, asyncio.TimeoutError): + if keep_request: + logger.error(f"模型 {self.model_name} 网络错误，等待{wait_time}秒后重试... 错误: {str(exception)}") + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical(f"模型 {self.model_name} 网络错误达到最大重试次数: {str(exception)}") + raise RuntimeError(f"网络请求失败: {str(exception)}") + + elif isinstance(exception, aiohttp.ClientResponseError): + # 处理aiohttp抛出的，除了policy中的status的响应错误 + if keep_request: + logger.error( + f"模型 {self.model_name} HTTP响应错误，等待{wait_time}秒后重试... 状态码: {exception.status}, 错误: {exception.message}" + ) + try: + error_text = await exception.response.text() + error_json = json.loads(error_text) + if isinstance(error_json, list) and len(error_json) > 0: + # 处理多个错误的情况 + for error_item in error_json: + if "error" in error_item and isinstance(error_item["error"], dict): + error_obj = error_item["error"] + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + elif isinstance(error_json, dict) and "error" in error_json: + error_obj = error_json.get("error", {}) + logger.error( + f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " + f"状态={error_obj.get('status')}, " + f"消息={error_obj.get('message')}" + ) + else: + logger.error(f"模型 {self.model_name} 服务器错误响应: {error_json}") + except (json.JSONDecodeError, TypeError) as json_err: + logger.warning( + f"模型 {self.model_name} 响应不是有效的JSON: {str(json_err)}, 原始内容: {error_text[:200]}" + ) + except Exception as parse_err: + logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") + + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical( + f"模型 {self.model_name} HTTP响应错误达到最大重试次数: 状态码: {exception.status}, 错误: {exception.message}" + ) + # 安全地检查和记录请求详情 + handled_payload = await self._safely_record(request_content, payload) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") + raise RuntimeError( + f"模型 {self.model_name} API请求失败: 状态码 {exception.status}, {exception.message}" + ) + + else: + if keep_request: + logger.error(f"模型 {self.model_name} 请求失败，等待{wait_time}秒后重试... 错误: {str(exception)}") + await asyncio.sleep(wait_time) + return None, 0 + else: + logger.critical(f"模型 {self.model_name} 请求失败: {str(exception)}") + # 安全地检查和记录请求详情 + handled_payload = await self._safely_record(request_content, payload) + logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") + raise RuntimeError(f"模型 {self.model_name} API请求失败: {str(exception)}") + + async def _safely_record(self, request_content: Dict[str, Any], payload: Dict[str, Any]): + image_base64: str = request_content.get("image_base64") + image_format: str = request_content.get("image_format") + if ( + image_base64 + and payload + and isinstance(payload, dict) + and "messages" in payload + and len(payload["messages"]) > 0 + ): + if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: + content = payload["messages"][0]["content"] + if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: + payload["messages"][0]["content"][1]["image_url"]["url"] = ( + f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," + f"{image_base64[:10]}...{image_base64[-10:]}" + ) + # if isinstance(content, str) and len(content) > 100: + # payload["messages"][0]["content"] = content[:100] + return payload async def _transform_parameters(self, params: dict) -> dict: """ diff --git a/src/plugins/models/utils_model_new.py b/src/plugins/models/utils_model_new.py deleted file mode 100644 index 1faebc3e..00000000 --- a/src/plugins/models/utils_model_new.py +++ /dev/null @@ -1,1233 +0,0 @@ -import asyncio -import json -import re -from datetime import datetime -from typing import Tuple, Union, Dict, Any - -import aiohttp -from aiohttp.client import ClientResponse - -from src.common.logger import get_module_logger -import base64 -from PIL import Image -import io -import os -from ...common.database import db -from ...config.config import global_config - -logger = get_module_logger("model_utils") - - -class PayLoadTooLargeError(Exception): - """自定义异常类，用于处理请求体过大错误""" - - def __init__(self, message: str): - super().__init__(message) - self.message = message - - def __str__(self): - return "请求体过大，请尝试压缩图片或减少输入内容。" - - -class RequestAbortException(Exception): - """自定义异常类，用于处理请求中断异常""" - - def __init__(self, message: str, response: ClientResponse): - super().__init__(message) - self.message = message - self.response = response - - def __str__(self): - return self.message - - -class PermissionDeniedException(Exception): - """自定义异常类，用于处理访问拒绝的异常""" - - def __init__(self, message: str): - super().__init__(message) - self.message = message - - def __str__(self): - return self.message - - -# 常见Error Code Mapping -error_code_mapping = { - 400: "参数不正确", - 401: "API key 错误，认证失败，请检查/config/bot_config.toml和.env中的配置是否正确哦~", - 402: "账号余额不足", - 403: "需要实名,或余额不足", - 404: "Not Found", - 429: "请求过于频繁，请稍后再试", - 500: "服务器内部故障", - 503: "服务器负载过高", -} - - -class LLMRequest: - # 定义需要转换的模型列表，作为类变量避免重复 - MODELS_NEEDING_TRANSFORMATION = [ - "o3-mini", - "o1-mini", - "o1-preview", - "o1-2024-12-17", - "o1-preview-2024-09-12", - "o3-mini-2025-01-31", - "o1-mini-2024-09-12", - ] - - def __init__(self, model: dict, **kwargs): - # 将大写的配置键转换为小写并从config中获取实际值 - try: - self.api_key = os.environ[model["key"]] - self.base_url = os.environ[model["base_url"]] - except AttributeError as e: - logger.error(f"原始 model dict 信息：{model}") - logger.error(f"配置错误：找不到对应的配置项 - {str(e)}") - raise ValueError(f"配置错误：找不到对应的配置项 - {str(e)}") from e - self.model_name: str = model["name"] - self.params = kwargs - - self.stream = model.get("stream", False) - self.pri_in = model.get("pri_in", 0) - self.pri_out = model.get("pri_out", 0) - - # 获取数据库实例 - self._init_database() - - # 从 kwargs 中提取 request_type，如果没有提供则默认为 "default" - self.request_type = kwargs.pop("request_type", "default") - - @staticmethod - def _init_database(): - """初始化数据库集合""" - try: - # 创建llm_usage集合的索引 - db.llm_usage.create_index([("timestamp", 1)]) - db.llm_usage.create_index([("model_name", 1)]) - db.llm_usage.create_index([("user_id", 1)]) - db.llm_usage.create_index([("request_type", 1)]) - except Exception as e: - logger.error(f"创建数据库索引失败: {str(e)}") - - def _record_usage( - self, - prompt_tokens: int, - completion_tokens: int, - total_tokens: int, - user_id: str = "system", - request_type: str = None, - endpoint: str = "/chat/completions", - ): - """记录模型使用情况到数据库 - Args: - prompt_tokens: 输入token数 - completion_tokens: 输出token数 - total_tokens: 总token数 - user_id: 用户ID，默认为system - request_type: 请求类型(chat/embedding/image/topic/schedule) - endpoint: API端点 - """ - # 如果 request_type 为 None，则使用实例变量中的值 - if request_type is None: - request_type = self.request_type - - try: - usage_data = { - "model_name": self.model_name, - "user_id": user_id, - "request_type": request_type, - "endpoint": endpoint, - "prompt_tokens": prompt_tokens, - "completion_tokens": completion_tokens, - "total_tokens": total_tokens, - "cost": self._calculate_cost(prompt_tokens, completion_tokens), - "status": "success", - "timestamp": datetime.now(), - } - db.llm_usage.insert_one(usage_data) - logger.trace( - f"Token使用情况 - 模型: {self.model_name}, " - f"用户: {user_id}, 类型: {request_type}, " - f"提示词: {prompt_tokens}, 完成: {completion_tokens}, " - f"总计: {total_tokens}" - ) - except Exception as e: - logger.error(f"记录token使用情况失败: {str(e)}") - - def _calculate_cost(self, prompt_tokens: int, completion_tokens: int) -> float: - """计算API调用成本 - 使用模型的pri_in和pri_out价格计算输入和输出的成本 - - Args: - prompt_tokens: 输入token数量 - completion_tokens: 输出token数量 - - Returns: - float: 总成本（元） - """ - # 使用模型的pri_in和pri_out计算成本 - input_cost = (prompt_tokens / 1000000) * self.pri_in - output_cost = (completion_tokens / 1000000) * self.pri_out - return round(input_cost + output_cost, 6) - - ''' - async def _execute_request( - self, - endpoint: str, - prompt: str = None, - image_base64: str = None, - image_format: str = None, - payload: dict = None, - retry_policy: dict = None, - response_handler: callable = None, - user_id: str = "system", - request_type: str = None, - ): - """统一请求执行入口 - Args: - endpoint: API端点路径 (如 "chat/completions") - prompt: prompt文本 - image_base64: 图片的base64编码 - image_format: 图片格式 - payload: 请求体数据 - retry_policy: 自定义重试策略 - response_handler: 自定义响应处理器 - user_id: 用户ID - request_type: 请求类型 - """ - - if request_type is None: - request_type = self.request_type - - # 合并重试策略 - default_retry = { - "max_retries": 3, - "base_wait": 10, - "retry_codes": [429, 413, 500, 503], - "abort_codes": [400, 401, 402, 403], - } - policy = {**default_retry, **(retry_policy or {})} - - # 常见Error Code Mapping - error_code_mapping = { - 400: "参数不正确", - 401: "API key 错误，认证失败，请检查/config/bot_config.toml和.env中的配置是否正确哦~", - 402: "账号余额不足", - 403: "需要实名,或余额不足", - 404: "Not Found", - 429: "请求过于频繁，请稍后再试", - 500: "服务器内部故障", - 503: "服务器负载过高", - } - - api_url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" - # 判断是否为流式 - stream_mode = self.stream - # logger_msg = "进入流式输出模式，" if stream_mode else "" - # logger.debug(f"{logger_msg}发送请求到URL: {api_url}") - # logger.info(f"使用模型: {self.model_name}") - - # 构建请求体 - if image_base64: - payload = await self._build_payload(prompt, image_base64, image_format) - elif payload is None: - payload = await self._build_payload(prompt) - - # 流式输出标志 - # 先构建payload，再添加流式输出标志 - if stream_mode: - payload["stream"] = stream_mode - - for retry in range(policy["max_retries"]): - try: - # 使用上下文管理器处理会话 - headers = await self._build_headers() - # 似乎是openai流式必须要的东西,不过阿里云的qwq-plus加了这个没有影响 - if stream_mode: - headers["Accept"] = "text/event-stream" - - async with aiohttp.ClientSession() as session: - try: - async with session.post(api_url, headers=headers, json=payload) as response: - # 处理需要重试的状态码 - if response.status in policy["retry_codes"]: - wait_time = policy["base_wait"] * (2**retry) - logger.warning( - f"模型 {self.model_name} 错误码: {response.status}, 等待 {wait_time}秒后重试" - ) - if response.status == 413: - logger.warning("请求体过大，尝试压缩...") - image_base64 = compress_base64_image_by_scale(image_base64) - payload = await self._build_payload(prompt, image_base64, image_format) - elif response.status in [500, 503]: - logger.error( - f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" - ) - raise RuntimeError("服务器负载过高，模型恢复失败QAQ") - else: - logger.warning(f"模型 {self.model_name} 请求限制(429)，等待{wait_time}秒后重试...") - - await asyncio.sleep(wait_time) - continue - elif response.status in policy["abort_codes"]: - logger.error( - f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" - ) - # 尝试获取并记录服务器返回的详细错误信息 - try: - error_json = await response.json() - if error_json and isinstance(error_json, list) and len(error_json) > 0: - for error_item in error_json: - if "error" in error_item and isinstance(error_item["error"], dict): - error_obj = error_item["error"] - error_code = error_obj.get("code") - error_message = error_obj.get("message") - error_status = error_obj.get("status") - logger.error( - f"服务器错误详情: 代码={error_code}, 状态={error_status}, " - f"消息={error_message}" - ) - elif isinstance(error_json, dict) and "error" in error_json: - # 处理单个错误对象的情况 - error_obj = error_json.get("error", {}) - error_code = error_obj.get("code") - error_message = error_obj.get("message") - error_status = error_obj.get("status") - logger.error( - f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}" - ) - else: - # 记录原始错误响应内容 - logger.error(f"服务器错误响应: {error_json}") - except Exception as e: - logger.warning(f"无法解析服务器错误响应: {str(e)}") - - if response.status == 403: - # 只针对硅基流动的V3和R1进行降级处理 - if ( - self.model_name.startswith("Pro/deepseek-ai") - and self.base_url == "https://api.siliconflow.cn/v1/" - ): - old_model_name = self.model_name - self.model_name = self.model_name[4:] # 移除"Pro/"前缀 - logger.warning( - f"检测到403错误，模型从 {old_model_name} 降级为 {self.model_name}" - ) - - # 对全局配置进行更新 - if global_config.llm_normal.get("name") == old_model_name: - global_config.llm_normal["name"] = self.model_name - logger.warning(f"将全局配置中的 llm_normal 模型临时降级至{self.model_name}") - - if global_config.llm_reasoning.get("name") == old_model_name: - global_config.llm_reasoning["name"] = self.model_name - logger.warning( - f"将全局配置中的 llm_reasoning 模型临时降级至{self.model_name}" - ) - - # 更新payload中的模型名 - if payload and "model" in payload: - payload["model"] = self.model_name - - # 重新尝试请求 - retry -= 1 # 不计入重试次数 - continue - - raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(response.status)}") - - response.raise_for_status() - reasoning_content = "" - - # 将流式输出转化为非流式输出 - if stream_mode: - flag_delta_content_finished = False - accumulated_content = "" - usage = None # 初始化usage变量，避免未定义错误 - - async for line_bytes in response.content: - try: - line = line_bytes.decode("utf-8").strip() - if not line: - continue - if line.startswith("data:"): - data_str = line[5:].strip() - if data_str == "[DONE]": - break - try: - chunk = json.loads(data_str) - if flag_delta_content_finished: - chunk_usage = chunk.get("usage", None) - if chunk_usage: - usage = chunk_usage # 获取token用量 - else: - delta = chunk["choices"][0]["delta"] - delta_content = delta.get("content") - if delta_content is None: - delta_content = "" - accumulated_content += delta_content - # 检测流式输出文本是否结束 - finish_reason = chunk["choices"][0].get("finish_reason") - if delta.get("reasoning_content", None): - reasoning_content += delta["reasoning_content"] - if finish_reason == "stop": - chunk_usage = chunk.get("usage", None) - if chunk_usage: - usage = chunk_usage - break - # 部分平台在文本输出结束前不会返回token用量，此时需要再获取一次chunk - flag_delta_content_finished = True - - except Exception as e: - logger.exception(f"模型 {self.model_name} 解析流式输出错误: {str(e)}") - except GeneratorExit: - logger.warning("模型 {self.model_name} 流式输出被中断，正在清理资源...") - # 确保资源被正确清理 - await response.release() - # 返回已经累积的内容 - result = { - "choices": [ - { - "message": { - "content": accumulated_content, - "reasoning_content": reasoning_content, - # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 - } - } - ], - "usage": usage, - } - return ( - response_handler(result) - if response_handler - else self._default_response_handler(result, user_id, request_type, endpoint) - ) - except Exception as e: - logger.error(f"模型 {self.model_name} 处理流式输出时发生错误: {str(e)}") - # 确保在发生错误时也能正确清理资源 - try: - await response.release() - except Exception as cleanup_error: - logger.error(f"清理资源时发生错误: {cleanup_error}") - # 返回已经累积的内容 - result = { - "choices": [ - { - "message": { - "content": accumulated_content, - "reasoning_content": reasoning_content, - # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 - } - } - ], - "usage": usage, - } - return ( - response_handler(result) - if response_handler - else self._default_response_handler(result, user_id, request_type, endpoint) - ) - content = accumulated_content - think_match = re.search(r"(.*?)", content, re.DOTALL) - if think_match: - reasoning_content = think_match.group(1).strip() - content = re.sub(r".*?", "", content, flags=re.DOTALL).strip() - # 构造一个伪result以便调用自定义响应处理器或默认处理器 - result = { - "choices": [ - { - "message": { - "content": content, - "reasoning_content": reasoning_content, - # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 - } - } - ], - "usage": usage, - } - return ( - response_handler(result) - if response_handler - else self._default_response_handler(result, user_id, request_type, endpoint) - ) - else: - result = await response.json() - # 使用自定义处理器或默认处理 - return ( - response_handler(result) - if response_handler - else self._default_response_handler(result, user_id, request_type, endpoint) - ) - - except (aiohttp.ClientError, asyncio.TimeoutError) as e: - if retry < policy["max_retries"] - 1: - wait_time = policy["base_wait"] * (2**retry) - logger.error(f"模型 {self.model_name} 网络错误，等待{wait_time}秒后重试... 错误: {str(e)}") - await asyncio.sleep(wait_time) - continue - else: - logger.critical(f"模型 {self.model_name} 网络错误达到最大重试次数: {str(e)}") - raise RuntimeError(f"网络请求失败: {str(e)}") from e - except Exception as e: - logger.critical(f"模型 {self.model_name} 未预期的错误: {str(e)}") - raise RuntimeError(f"请求过程中发生错误: {str(e)}") from e - - except aiohttp.ClientResponseError as e: - # 处理aiohttp抛出的响应错误 - if retry < policy["max_retries"] - 1: - wait_time = policy["base_wait"] * (2**retry) - logger.error( - f"模型 {self.model_name} HTTP响应错误，等待{wait_time}秒后重试... 状态码: {e.status}, 错误: {e.message}" - ) - try: - if hasattr(e, "response") and e.response and hasattr(e.response, "text"): - error_text = await e.response.text() - try: - error_json = json.loads(error_text) - if isinstance(error_json, list) and len(error_json) > 0: - for error_item in error_json: - if "error" in error_item and isinstance(error_item["error"], dict): - error_obj = error_item["error"] - logger.error( - f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " - f"状态={error_obj.get('status')}, " - f"消息={error_obj.get('message')}" - ) - elif isinstance(error_json, dict) and "error" in error_json: - error_obj = error_json.get("error", {}) - logger.error( - f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " - f"状态={error_obj.get('status')}, " - f"消息={error_obj.get('message')}" - ) - else: - logger.error(f"模型 {self.model_name} 服务器错误响应: {error_json}") - except (json.JSONDecodeError, TypeError) as json_err: - logger.warning( - f"模型 {self.model_name} 响应不是有效的JSON: {str(json_err)}, 原始内容: {error_text[:200]}" - ) - except (AttributeError, TypeError, ValueError) as parse_err: - logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") - - await asyncio.sleep(wait_time) - else: - logger.critical( - f"模型 {self.model_name} HTTP响应错误达到最大重试次数: 状态码: {e.status}, 错误: {e.message}" - ) - # 安全地检查和记录请求详情 - if ( - image_base64 - and payload - and isinstance(payload, dict) - and "messages" in payload - and len(payload["messages"]) > 0 - ): - if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: - content = payload["messages"][0]["content"] - if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: - payload["messages"][0]["content"][1]["image_url"]["url"] = ( - f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," - f"{image_base64[:10]}...{image_base64[-10:]}" - ) - logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {payload}") - raise RuntimeError(f"模型 {self.model_name} API请求失败: 状态码 {e.status}, {e.message}") from e - except Exception as e: - if retry < policy["max_retries"] - 1: - wait_time = policy["base_wait"] * (2**retry) - logger.error(f"模型 {self.model_name} 请求失败，等待{wait_time}秒后重试... 错误: {str(e)}") - await asyncio.sleep(wait_time) - else: - logger.critical(f"模型 {self.model_name} 请求失败: {str(e)}") - # 安全地检查和记录请求详情 - if ( - image_base64 - and payload - and isinstance(payload, dict) - and "messages" in payload - and len(payload["messages"]) > 0 - ): - if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: - content = payload["messages"][0]["content"] - if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: - payload["messages"][0]["content"][1]["image_url"]["url"] = ( - f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," - f"{image_base64[:10]}...{image_base64[-10:]}" - ) - logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {payload}") - raise RuntimeError(f"模型 {self.model_name} API请求失败: {str(e)}") from e - - logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") - raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") - ''' - - async def _prepare_request( - self, - endpoint: str, - prompt: str = None, - image_base64: str = None, - image_format: str = None, - payload: dict = None, - retry_policy: dict = None, - ) -> Dict[str, Any]: - """配置请求参数 - Args: - endpoint: API端点路径 (如 "chat/completions") - prompt: prompt文本 - image_base64: 图片的base64编码 - image_format: 图片格式 - payload: 请求体数据 - retry_policy: 自定义重试策略 - request_type: 请求类型 - """ - - # 合并重试策略 - default_retry = { - "max_retries": 3, - "base_wait": 10, - "retry_codes": [429, 413, 500, 503], - "abort_codes": [400, 401, 402, 403], - } - policy = {**default_retry, **(retry_policy or {})} - - api_url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" - - stream_mode = self.stream - - # 构建请求体 - if image_base64: - payload = await self._build_payload(prompt, image_base64, image_format) - elif payload is None: - payload = await self._build_payload(prompt) - - if stream_mode: - payload["stream"] = stream_mode - - return { - "policy": policy, - "payload": payload, - "api_url": api_url, - "stream_mode": stream_mode, - "image_base64": image_base64, # 保留必要的exception处理所需的原始数据 - "image_format": image_format, - "prompt": prompt, - } - - async def _execute_request( - self, - endpoint: str, - prompt: str = None, - image_base64: str = None, - image_format: str = None, - payload: dict = None, - retry_policy: dict = None, - response_handler: callable = None, - user_id: str = "system", - request_type: str = None, - ): - """统一请求执行入口 - Args: - endpoint: API端点路径 (如 "chat/completions") - prompt: prompt文本 - image_base64: 图片的base64编码 - image_format: 图片格式 - payload: 请求体数据 - retry_policy: 自定义重试策略 - response_handler: 自定义响应处理器 - user_id: 用户ID - request_type: 请求类型 - """ - # 获取请求配置 - request_content = await self._prepare_request( - endpoint, prompt, image_base64, image_format, payload, retry_policy - ) - if request_type is None: - request_type = self.request_type - for retry in range(request_content["policy"]["max_retries"]): - try: - # 使用上下文管理器处理会话 - headers = await self._build_headers() - # 似乎是openai流式必须要的东西,不过阿里云的qwq-plus加了这个没有影响 - if request_content["stream_mode"]: - headers["Accept"] = "text/event-stream" - async with aiohttp.ClientSession() as session: - async with session.post( - request_content["api_url"], headers=headers, json=request_content["payload"] - ) as response: - handled_result = await self._handle_response( - response, request_content, retry, response_handler, user_id, request_type, endpoint - ) - return handled_result - except Exception as e: - handled_payload, count_delta = await self._handle_exception(e, retry, request_content) - retry += count_delta # 降级不计入重试次数 - if handled_payload: - # 如果降级成功，重新构建请求体 - request_content["payload"] = handled_payload - continue - - logger.error(f"模型 {self.model_name} 达到最大重试次数，请求仍然失败") - raise RuntimeError(f"模型 {self.model_name} 达到最大重试次数，API请求仍然失败") - - async def _handle_response( - self, - response: ClientResponse, - request_content: Dict[str, Any], - retry_count: int, - response_handler: callable, - user_id, - request_type, - endpoint, - ) -> Union[Dict[str, Any], None]: - policy = request_content["policy"] - stream_mode = request_content["stream_mode"] - if response.status in policy["retry_codes"] or response.status in policy["abort_codes"]: - await self._handle_error_response(response, retry_count, policy) - return - - response.raise_for_status() - result = {} - if stream_mode: - # 将流式输出转化为非流式输出 - result = await self._handle_stream_output(response) - else: - result = await response.json() - return ( - response_handler(result) - if response_handler - else self._default_response_handler(result, user_id, request_type, endpoint) - ) - - async def _handle_stream_output(self, response: ClientResponse) -> Dict[str, Any]: - flag_delta_content_finished = False - accumulated_content = "" - usage = None # 初始化usage变量，避免未定义错误 - reasoning_content = "" - content = "" - async for line_bytes in response.content: - try: - line = line_bytes.decode("utf-8").strip() - if not line: - continue - if line.startswith("data:"): - data_str = line[5:].strip() - if data_str == "[DONE]": - break - try: - chunk = json.loads(data_str) - if flag_delta_content_finished: - chunk_usage = chunk.get("usage", None) - if chunk_usage: - usage = chunk_usage # 获取token用量 - else: - delta = chunk["choices"][0]["delta"] - delta_content = delta.get("content") - if delta_content is None: - delta_content = "" - accumulated_content += delta_content - # 检测流式输出文本是否结束 - finish_reason = chunk["choices"][0].get("finish_reason") - if delta.get("reasoning_content", None): - reasoning_content += delta["reasoning_content"] - if finish_reason == "stop": - chunk_usage = chunk.get("usage", None) - if chunk_usage: - usage = chunk_usage - break - # 部分平台在文本输出结束前不会返回token用量，此时需要再获取一次chunk - flag_delta_content_finished = True - except Exception as e: - logger.exception(f"模型 {self.model_name} 解析流式输出错误: {str(e)}") - except Exception as e: - if isinstance(e, GeneratorExit): - log_content = f"模型 {self.model_name} 流式输出被中断，正在清理资源..." - else: - log_content = f"模型 {self.model_name} 处理流式输出时发生错误: {str(e)}" - logger.warning(log_content) - # 确保资源被正确清理 - try: - await response.release() - except Exception as cleanup_error: - logger.error(f"清理资源时发生错误: {cleanup_error}") - # 返回已经累积的内容 - content = accumulated_content - if not content: - content = accumulated_content - think_match = re.search(r"(.*?)", content, re.DOTALL) - if think_match: - reasoning_content = think_match.group(1).strip() - content = re.sub(r".*?", "", content, flags=re.DOTALL).strip() - result = { - "choices": [ - { - "message": { - "content": content, - "reasoning_content": reasoning_content, - # 流式输出可能没有工具调用，此处不需要添加tool_calls字段 - } - } - ], - "usage": usage, - } - return result - - async def _handle_error_response( - self, response: ClientResponse, retry_count: int, policy: Dict[str, Any] - ) -> Union[Dict[str, any]]: - if response.status in policy["retry_codes"]: - wait_time = policy["base_wait"] * (2**retry_count) - logger.warning(f"模型 {self.model_name} 错误码: {response.status}, 等待 {wait_time}秒后重试") - if response.status == 413: - logger.warning("请求体过大，尝试压缩...") - raise PayLoadTooLargeError("请求体过大") - elif response.status in [500, 503]: - logger.error( - f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" - ) - raise RuntimeError("服务器负载过高，模型恢复失败QAQ") - else: - logger.warning(f"模型 {self.model_name} 请求限制(429)，等待{wait_time}秒后重试...") - raise RuntimeError("请求限制(429)") - elif response.status in policy["abort_codes"]: - if response.status != 403: - raise RequestAbortException("请求出现错误，中断处理", response) - else: - raise PermissionDeniedException("模型禁止访问") - - async def _handle_exception( - self, exception, retry_count: int, request_content: Dict[str, Any] - ) -> Union[Tuple[Dict[str, Any], int], Tuple[None, int]]: - policy = request_content["policy"] - payload = request_content["payload"] - keep_request = False - if retry_count < policy["max_retries"] - 1: - wait_time = policy["base_wait"] * (2**retry_count) - keep_request = True - if isinstance(exception, RequestAbortException): - response = exception.response - logger.error( - f"模型 {self.model_name} 错误码: {response.status} - {error_code_mapping.get(response.status)}" - ) - # 尝试获取并记录服务器返回的详细错误信息 - try: - error_json = await response.json() - if error_json and isinstance(error_json, list) and len(error_json) > 0: - # 处理多个错误的情况 - for error_item in error_json: - if "error" in error_item and isinstance(error_item["error"], dict): - error_obj: dict = error_item["error"] - error_code = error_obj.get("code") - error_message = error_obj.get("message") - error_status = error_obj.get("status") - logger.error( - f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}" - ) - elif isinstance(error_json, dict) and "error" in error_json: - # 处理单个错误对象的情况 - error_obj = error_json.get("error", {}) - error_code = error_obj.get("code") - error_message = error_obj.get("message") - error_status = error_obj.get("status") - logger.error(f"服务器错误详情: 代码={error_code}, 状态={error_status}, 消息={error_message}") - else: - # 记录原始错误响应内容 - logger.error(f"服务器错误响应: {error_json}") - except Exception as e: - logger.warning(f"无法解析服务器错误响应: {str(e)}") - raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(response.status)}") - - elif isinstance(exception, PermissionDeniedException): - # 只针对硅基流动的V3和R1进行降级处理 - if self.model_name.startswith("Pro/deepseek-ai") and self.base_url == "https://api.siliconflow.cn/v1/": - old_model_name = self.model_name - self.model_name = self.model_name[4:] # 移除"Pro/"前缀 - logger.warning(f"检测到403错误，模型从 {old_model_name} 降级为 {self.model_name}") - - # 对全局配置进行更新 - if global_config.llm_normal.get("name") == old_model_name: - global_config.llm_normal["name"] = self.model_name - logger.warning(f"将全局配置中的 llm_normal 模型临时降级至{self.model_name}") - if global_config.llm_reasoning.get("name") == old_model_name: - global_config.llm_reasoning["name"] = self.model_name - logger.warning(f"将全局配置中的 llm_reasoning 模型临时降级至{self.model_name}") - - if payload and "model" in payload: - payload["model"] = self.model_name - - await asyncio.sleep(wait_time) - return payload, -1 - raise RuntimeError(f"请求被拒绝: {error_code_mapping.get(403)}") - - elif isinstance(exception, PayLoadTooLargeError): - if keep_request: - image_base64 = request_content["image_base64"] - compressed_image_base64 = compress_base64_image_by_scale(image_base64) - new_payload = await self._build_payload( - request_content["prompt"], compressed_image_base64, request_content["image_format"] - ) - return new_payload, 0 - else: - return None, 0 - - elif isinstance(exception, aiohttp.ClientError) or isinstance(exception, asyncio.TimeoutError): - if keep_request: - logger.error(f"模型 {self.model_name} 网络错误，等待{wait_time}秒后重试... 错误: {str(exception)}") - await asyncio.sleep(wait_time) - return None, 0 - else: - logger.critical(f"模型 {self.model_name} 网络错误达到最大重试次数: {str(exception)}") - raise RuntimeError(f"网络请求失败: {str(exception)}") - - elif isinstance(exception, aiohttp.ClientResponseError): - # 处理aiohttp抛出的，除了policy中的status的响应错误 - if keep_request: - logger.error( - f"模型 {self.model_name} HTTP响应错误，等待{wait_time}秒后重试... 状态码: {exception.status}, 错误: {exception.message}" - ) - try: - error_text = await exception.response.text() - error_json = json.loads(error_text) - if isinstance(error_json, list) and len(error_json) > 0: - # 处理多个错误的情况 - for error_item in error_json: - if "error" in error_item and isinstance(error_item["error"], dict): - error_obj = error_item["error"] - logger.error( - f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " - f"状态={error_obj.get('status')}, " - f"消息={error_obj.get('message')}" - ) - elif isinstance(error_json, dict) and "error" in error_json: - error_obj = error_json.get("error", {}) - logger.error( - f"模型 {self.model_name} 服务器错误详情: 代码={error_obj.get('code')}, " - f"状态={error_obj.get('status')}, " - f"消息={error_obj.get('message')}" - ) - else: - logger.error(f"模型 {self.model_name} 服务器错误响应: {error_json}") - except (json.JSONDecodeError, TypeError) as json_err: - logger.warning( - f"模型 {self.model_name} 响应不是有效的JSON: {str(json_err)}, 原始内容: {error_text[:200]}" - ) - except Exception as parse_err: - logger.warning(f"模型 {self.model_name} 无法解析响应错误内容: {str(parse_err)}") - - await asyncio.sleep(wait_time) - return None, 0 - else: - logger.critical( - f"模型 {self.model_name} HTTP响应错误达到最大重试次数: 状态码: {exception.status}, 错误: {exception.message}" - ) - # 安全地检查和记录请求详情 - handled_payload = await self._safely_record(request_content, payload) - logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") - raise RuntimeError( - f"模型 {self.model_name} API请求失败: 状态码 {exception.status}, {exception.message}" - ) - - else: - if keep_request: - logger.error(f"模型 {self.model_name} 请求失败，等待{wait_time}秒后重试... 错误: {str(exception)}") - await asyncio.sleep(wait_time) - return None, 0 - else: - logger.critical(f"模型 {self.model_name} 请求失败: {str(exception)}") - # 安全地检查和记录请求详情 - handled_payload = await self._safely_record(request_content, payload) - logger.critical(f"请求头: {await self._build_headers(no_key=True)} 请求体: {handled_payload}") - raise RuntimeError(f"模型 {self.model_name} API请求失败: {str(exception)}") - - async def _safely_record(self, request_content: Dict[str, Any], payload: Dict[str, Any]): - image_base64: str = request_content.get("image_base64") - image_format: str = request_content.get("image_format") - if ( - image_base64 - and payload - and isinstance(payload, dict) - and "messages" in payload - and len(payload["messages"]) > 0 - ): - if isinstance(payload["messages"][0], dict) and "content" in payload["messages"][0]: - content = payload["messages"][0]["content"] - if isinstance(content, list) and len(content) > 1 and "image_url" in content[1]: - payload["messages"][0]["content"][1]["image_url"]["url"] = ( - f"data:image/{image_format.lower() if image_format else 'jpeg'};base64," - f"{image_base64[:10]}...{image_base64[-10:]}" - ) - # if isinstance(content, str) and len(content) > 100: - # payload["messages"][0]["content"] = content[:100] - return payload - - async def _transform_parameters(self, params: dict) -> dict: - """ - 根据模型名称转换参数： - - 对于需要转换的OpenAI CoT系列模型（例如 "o3-mini"），删除 'temperature' 参数， - 并将 'max_tokens' 重命名为 'max_completion_tokens' - """ - # 复制一份参数，避免直接修改原始数据 - new_params = dict(params) - - if self.model_name.lower() in self.MODELS_NEEDING_TRANSFORMATION: - # 删除 'temperature' 参数（如果存在） - new_params.pop("temperature", None) - # 如果存在 'max_tokens'，则重命名为 'max_completion_tokens' - if "max_tokens" in new_params: - new_params["max_completion_tokens"] = new_params.pop("max_tokens") - return new_params - - async def _build_payload(self, prompt: str, image_base64: str = None, image_format: str = None) -> dict: - """构建请求体""" - # 复制一份参数，避免直接修改 self.params - params_copy = await self._transform_parameters(self.params) - if image_base64: - payload = { - "model": self.model_name, - "messages": [ - { - "role": "user", - "content": [ - {"type": "text", "text": prompt}, - { - "type": "image_url", - "image_url": {"url": f"data:image/{image_format.lower()};base64,{image_base64}"}, - }, - ], - } - ], - "max_tokens": global_config.max_response_length, - **params_copy, - } - else: - payload = { - "model": self.model_name, - "messages": [{"role": "user", "content": prompt}], - "max_tokens": global_config.max_response_length, - **params_copy, - } - # 如果 payload 中依然存在 max_tokens 且需要转换，在这里进行再次检查 - if self.model_name.lower() in self.MODELS_NEEDING_TRANSFORMATION and "max_tokens" in payload: - payload["max_completion_tokens"] = payload.pop("max_tokens") - return payload - - def _default_response_handler( - self, result: dict, user_id: str = "system", request_type: str = None, endpoint: str = "/chat/completions" - ) -> Tuple: - """默认响应解析""" - if "choices" in result and result["choices"]: - message = result["choices"][0]["message"] - content = message.get("content", "") - content, reasoning = self._extract_reasoning(content) - reasoning_content = message.get("model_extra", {}).get("reasoning_content", "") - if not reasoning_content: - reasoning_content = message.get("reasoning_content", "") - if not reasoning_content: - reasoning_content = reasoning - - # 提取工具调用信息 - tool_calls = message.get("tool_calls", None) - - # 记录token使用情况 - usage = result.get("usage", {}) - if usage: - prompt_tokens = usage.get("prompt_tokens", 0) - completion_tokens = usage.get("completion_tokens", 0) - total_tokens = usage.get("total_tokens", 0) - self._record_usage( - prompt_tokens=prompt_tokens, - completion_tokens=completion_tokens, - total_tokens=total_tokens, - user_id=user_id, - request_type=request_type if request_type is not None else self.request_type, - endpoint=endpoint, - ) - - # 只有当tool_calls存在且不为空时才返回 - if tool_calls: - return content, reasoning_content, tool_calls - else: - return content, reasoning_content - - return "没有返回结果", "" - - @staticmethod - def _extract_reasoning(content: str) -> Tuple[str, str]: - """CoT思维链提取""" - match = re.search(r"(?:)?(.*?)", content, re.DOTALL) - content = re.sub(r"(?:)?.*?", "", content, flags=re.DOTALL, count=1).strip() - if match: - reasoning = match.group(1).strip() - else: - reasoning = "" - return content, reasoning - - async def _build_headers(self, no_key: bool = False) -> dict: - """构建请求头""" - if no_key: - return {"Authorization": "Bearer **********", "Content-Type": "application/json"} - else: - return {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"} - # 防止小朋友们截图自己的key - - async def generate_response(self, prompt: str) -> Tuple: - """根据输入的提示生成模型的异步响应""" - - response = await self._execute_request(endpoint="/chat/completions", prompt=prompt) - # 根据返回值的长度决定怎么处理 - if len(response) == 3: - content, reasoning_content, tool_calls = response - return content, reasoning_content, self.model_name, tool_calls - else: - content, reasoning_content = response - return content, reasoning_content, self.model_name - - async def generate_response_for_image(self, prompt: str, image_base64: str, image_format: str) -> Tuple: - """根据输入的提示和图片生成模型的异步响应""" - - response = await self._execute_request( - endpoint="/chat/completions", prompt=prompt, image_base64=image_base64, image_format=image_format - ) - # 根据返回值的长度决定怎么处理 - if len(response) == 3: - content, reasoning_content, tool_calls = response - return content, reasoning_content, tool_calls - else: - content, reasoning_content = response - return content, reasoning_content - - async def generate_response_async(self, prompt: str, **kwargs) -> Union[str, Tuple]: - """异步方式根据输入的提示生成模型的响应""" - # 构建请求体 - data = { - "model": self.model_name, - "messages": [{"role": "user", "content": prompt}], - "max_tokens": global_config.max_response_length, - **self.params, - **kwargs, - } - - response = await self._execute_request(endpoint="/chat/completions", payload=data, prompt=prompt) - # 原样返回响应，不做处理 - return response - - async def get_embedding(self, text: str) -> Union[list, None]: - """异步方法：获取文本的embedding向量 - - Args: - text: 需要获取embedding的文本 - - Returns: - list: embedding向量，如果失败则返回None - """ - - if len(text) < 1: - logger.debug("该消息没有长度，不再发送获取embedding向量的请求") - return None - - def embedding_handler(result): - """处理响应""" - if "data" in result and len(result["data"]) > 0: - # 提取 token 使用信息 - usage = result.get("usage", {}) - if usage: - prompt_tokens = usage.get("prompt_tokens", 0) - completion_tokens = usage.get("completion_tokens", 0) - total_tokens = usage.get("total_tokens", 0) - # 记录 token 使用情况 - self._record_usage( - prompt_tokens=prompt_tokens, - completion_tokens=completion_tokens, - total_tokens=total_tokens, - user_id="system", # 可以根据需要修改 user_id - # request_type="embedding", # 请求类型为 embedding - request_type=self.request_type, # 请求类型为 text - endpoint="/embeddings", # API 端点 - ) - return result["data"][0].get("embedding", None) - return result["data"][0].get("embedding", None) - return None - - embedding = await self._execute_request( - endpoint="/embeddings", - prompt=text, - payload={"model": self.model_name, "input": text, "encoding_format": "float"}, - retry_policy={"max_retries": 2, "base_wait": 6}, - response_handler=embedding_handler, - ) - return embedding - - -def compress_base64_image_by_scale(base64_data: str, target_size: int = 0.8 * 1024 * 1024) -> str: - """压缩base64格式的图片到指定大小 - Args: - base64_data: base64编码的图片数据 - target_size: 目标文件大小（字节），默认0.8MB - Returns: - str: 压缩后的base64图片数据 - """ - try: - # 将base64转换为字节数据 - image_data = base64.b64decode(base64_data) - - # 如果已经小于目标大小，直接返回原图 - if len(image_data) <= 2 * 1024 * 1024: - return base64_data - - # 将字节数据转换为图片对象 - img = Image.open(io.BytesIO(image_data)) - - # 获取原始尺寸 - original_width, original_height = img.size - - # 计算缩放比例 - scale = min(1.0, (target_size / len(image_data)) ** 0.5) - - # 计算新的尺寸 - new_width = int(original_width * scale) - new_height = int(original_height * scale) - - # 创建内存缓冲区 - output_buffer = io.BytesIO() - - # 如果是GIF，处理所有帧 - if getattr(img, "is_animated", False): - frames = [] - for frame_idx in range(img.n_frames): - img.seek(frame_idx) - new_frame = img.copy() - new_frame = new_frame.resize((new_width // 2, new_height // 2), Image.Resampling.LANCZOS) # 动图折上折 - frames.append(new_frame) - - # 保存到缓冲区 - frames[0].save( - output_buffer, - format="GIF", - save_all=True, - append_images=frames[1:], - optimize=True, - duration=img.info.get("duration", 100), - loop=img.info.get("loop", 0), - ) - else: - # 处理静态图片 - resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS) - - # 保存到缓冲区，保持原始格式 - if img.format == "PNG" and img.mode in ("RGBA", "LA"): - resized_img.save(output_buffer, format="PNG", optimize=True) - else: - resized_img.save(output_buffer, format="JPEG", quality=95, optimize=True) - - # 获取压缩后的数据并转换为base64 - compressed_data = output_buffer.getvalue() - logger.success(f"压缩图片: {original_width}x{original_height} -> {new_width}x{new_height}") - logger.info(f"压缩前大小: {len(image_data) / 1024:.1f}KB, 压缩后大小: {len(compressed_data) / 1024:.1f}KB") - - return base64.b64encode(compressed_data).decode("utf-8") - - except Exception as e: - logger.error(f"压缩图片失败: {str(e)}") - import traceback - - logger.error(traceback.format_exc()) - return base64_data From 58c66c5c9b248de653f4a2f1d6f77d39e3fb8b26 Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 10:49:13 +0800 Subject: [PATCH 04/26] =?UTF-8?q?better=EF=BC=9A=E4=BC=98=E5=8C=96?= =?UTF-8?q?=E8=AE=B0=E5=BF=86=E6=8F=90=E5=8F=96=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/heart_flow/heartflow.py | 4 ++-- src/heart_flow/observation.py | 2 +- src/plugins/chat_module/heartFC_chat/messagesender.py | 3 +-- src/plugins/memory_system/Hippocampus.py | 5 ++--- template/bot_config_template.toml | 2 +- 5 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/heart_flow/heartflow.py b/src/heart_flow/heartflow.py index 793f406f..5d53a07d 100644 --- a/src/heart_flow/heartflow.py +++ b/src/heart_flow/heartflow.py @@ -96,7 +96,7 @@ class Heartflow: continue await self.do_a_thinking() - await asyncio.sleep(global_config.heart_flow_update_interval) # 5分钟思考一次 + await asyncio.sleep(global_config.heart_flow_update_interval * 3) # 5分钟思考一次 async def heartflow_start_working(self): # 启动清理任务 @@ -110,7 +110,7 @@ class Heartflow: print("TODO") async def do_a_thinking(self): - logger.debug("麦麦大脑袋转起来了") + # logger.debug("麦麦大脑袋转起来了") self.current_state.update_current_state_info() # 开始构建prompt diff --git a/src/heart_flow/observation.py b/src/heart_flow/observation.py index 9903b184..49efe7eb 100644 --- a/src/heart_flow/observation.py +++ b/src/heart_flow/observation.py @@ -139,7 +139,7 @@ class ChattingObservation(Observation): # traceback.print_exc() # 记录详细堆栈 # print(f"处理后self.talking_message：{self.talking_message}") - self.talking_message_str = await build_readable_messages(self.talking_message) + self.talking_message_str = await build_readable_messages(messages=self.talking_message, timestamp_mode="normal") logger.trace( f"Chat {self.chat_id} - 压缩早期记忆：{self.mid_memory_info}\n现在聊天内容：{self.talking_message_str}" diff --git a/src/plugins/chat_module/heartFC_chat/messagesender.py b/src/plugins/chat_module/heartFC_chat/messagesender.py index fb295bed..897bc45f 100644 --- a/src/plugins/chat_module/heartFC_chat/messagesender.py +++ b/src/plugins/chat_module/heartFC_chat/messagesender.py @@ -220,9 +220,8 @@ class MessageManager: await asyncio.sleep(typing_time) logger.debug(f"\n{message_earliest.processed_plain_text},{typing_time},等待输入时间结束\n") - await self.storage.store_message(message_earliest, message_earliest.chat_stream) - await MessageSender().send_message(message_earliest) + await self.storage.store_message(message_earliest, message_earliest.chat_stream) container.remove_message(message_earliest) diff --git a/src/plugins/memory_system/Hippocampus.py b/src/plugins/memory_system/Hippocampus.py index 557b42f2..4b40649d 100644 --- a/src/plugins/memory_system/Hippocampus.py +++ b/src/plugins/memory_system/Hippocampus.py @@ -1946,15 +1946,14 @@ class HippocampusManager: valid_keywords: list[str], max_memory_num: int = 3, max_memory_length: int = 2, - max_depth: int = 3, - fast_retrieval: bool = False, + max_depth: int = 3 ) -> list: """从文本中获取相关记忆的公共接口""" if not self._initialized: raise RuntimeError("HippocampusManager 尚未初始化，请先调用 initialize 方法") try: response = await self._hippocampus.get_memory_from_topic( - valid_keywords, max_memory_num, max_memory_length, max_depth, fast_retrieval + valid_keywords, max_memory_num, max_memory_length, max_depth ) except Exception as e: logger.error(f"文本激活记忆失败: {e}") diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index f0a52e76..3ebf1459 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "1.3.1" +version = "1.4.0" #以下是给开发人员阅读的，一般用户不需要阅读 From 7e0f41c0395df7b897a534cf08fb8df21eefee30 Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 12:34:00 +0800 Subject: [PATCH 05/26] =?UTF-8?q?fix=EF=BC=9A=E4=BF=AE=E6=94=B9config?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/config/config.py | 62 +++++++----- src/heart_flow/heartflow.py | 99 ++++++++++++------- src/heart_flow/sub_heartflow.py | 28 ++---- src/plugins/chat/bot.py | 63 ++++-------- .../chat_module/heartFC_chat/pf_chatting.py | 5 +- template/bot_config_template.toml | 77 ++++++++------- 6 files changed, 179 insertions(+), 155 deletions(-) diff --git a/src/config/config.py b/src/config/config.py index 0dae0244..d2fe6f0f 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -186,12 +186,18 @@ class BotConfig: ban_words = set() ban_msgs_regex = set() - # heartflow - # enable_heartflow: bool = False # 是否启用心流 - sub_heart_flow_update_interval: int = 60 # 子心流更新频率，间隔 单位秒 - sub_heart_flow_freeze_time: int = 120 # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒 + # [heartflow] # 启用启用heart_flowC(心流聊天)模式时生效, 需要填写token消耗量巨大的相关模型 + # 启用后麦麦会自主选择进入heart_flowC模式(持续一段时间), 进行长时间高质量的聊天 + enable_heart_flowC: bool = True # 是否启用heart_flowC(心流聊天, HFC)模式 + reply_trigger_threshold: float = 3.0 # 心流聊天触发阈值，越低越容易触发 + probability_decay_factor_per_second: float = 0.2 # 概率衰减因子，越大衰减越快 + default_decay_rate_per_second: float = 0.98 # 默认衰减率，越大衰减越慢 + initial_duration: int = 60 # 初始持续时间，越大心流聊天持续的时间越长 + + # sub_heart_flow_update_interval: int = 60 # 子心流更新频率，间隔 单位秒 + # sub_heart_flow_freeze_time: int = 120 # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒 sub_heart_flow_stop_time: int = 600 # 子心流停止时间，超过这个时间没有回复，子心流会停止，间隔 单位秒 - heart_flow_update_interval: int = 300 # 心流更新频率，间隔 单位秒 + # heart_flow_update_interval: int = 300 # 心流更新频率，间隔 单位秒 observation_context_size: int = 20 # 心流观察到的最长上下文大小，超过这个值的上下文会被压缩 compressed_length: int = 5 # 不能大于observation_context_size,心流上下文压缩的最短压缩长度，超过心流观察到的上下文长度，会压缩，最短压缩长度为5 compress_length_limit: int = 5 # 最多压缩份数，超过该数值的压缩上下文会被删除 @@ -207,8 +213,8 @@ class BotConfig: # response response_mode: str = "heart_flow" # 回复策略 - MODEL_R1_PROBABILITY: float = 0.8 # R1模型概率 - MODEL_V3_PROBABILITY: float = 0.1 # V3模型概率 + model_reasoning_probability: float = 0.7 # 麦麦回答时选择推理模型(主要)模型概率 + model_normal_probability: float = 0.3 # 麦麦回答时选择一般模型(次要)模型概率 # MODEL_R1_DISTILL_PROBABILITY: float = 0.1 # R1蒸馏模型概率 # emoji @@ -401,29 +407,32 @@ class BotConfig: def response(parent: dict): response_config = parent["response"] - config.MODEL_R1_PROBABILITY = response_config.get("model_r1_probability", config.MODEL_R1_PROBABILITY) - config.MODEL_V3_PROBABILITY = response_config.get("model_v3_probability", config.MODEL_V3_PROBABILITY) - # config.MODEL_R1_DISTILL_PROBABILITY = response_config.get( - # "model_r1_distill_probability", config.MODEL_R1_DISTILL_PROBABILITY - # ) - config.max_response_length = response_config.get("max_response_length", config.max_response_length) - if config.INNER_VERSION in SpecifierSet(">=1.0.4"): - config.response_mode = response_config.get("response_mode", config.response_mode) + config.model_reasoning_probability = response_config.get("model_reasoning_probability", config.model_reasoning_probability) + config.model_normal_probability = response_config.get("model_normal_probability", config.model_normal_probability) + + + # 添加 enable_heart_flowC 的加载逻辑 (假设它在 [response] 部分) + if config.INNER_VERSION in SpecifierSet(">=1.4.0"): + config.enable_heart_flowC = response_config.get("enable_heart_flowC", config.enable_heart_flowC) def heartflow(parent: dict): heartflow_config = parent["heartflow"] - config.sub_heart_flow_update_interval = heartflow_config.get( - "sub_heart_flow_update_interval", config.sub_heart_flow_update_interval - ) - config.sub_heart_flow_freeze_time = heartflow_config.get( - "sub_heart_flow_freeze_time", config.sub_heart_flow_freeze_time - ) + # 加载新增的 heartflowC 参数 + + + # 加载原有的 heartflow 参数 + # config.sub_heart_flow_update_interval = heartflow_config.get( + # "sub_heart_flow_update_interval", config.sub_heart_flow_update_interval + # ) + # config.sub_heart_flow_freeze_time = heartflow_config.get( + # "sub_heart_flow_freeze_time", config.sub_heart_flow_freeze_time + # ) config.sub_heart_flow_stop_time = heartflow_config.get( "sub_heart_flow_stop_time", config.sub_heart_flow_stop_time ) - config.heart_flow_update_interval = heartflow_config.get( - "heart_flow_update_interval", config.heart_flow_update_interval - ) + # config.heart_flow_update_interval = heartflow_config.get( + # "heart_flow_update_interval", config.heart_flow_update_interval + # ) if config.INNER_VERSION in SpecifierSet(">=1.3.0"): config.observation_context_size = heartflow_config.get( "observation_context_size", config.observation_context_size @@ -432,6 +441,11 @@ class BotConfig: config.compress_length_limit = heartflow_config.get( "compress_length_limit", config.compress_length_limit ) + if config.INNER_VERSION in SpecifierSet(">=1.4.0"): + config.reply_trigger_threshold = heartflow_config.get("reply_trigger_threshold", config.reply_trigger_threshold) + config.probability_decay_factor_per_second = heartflow_config.get("probability_decay_factor_per_second", config.probability_decay_factor_per_second) + config.default_decay_rate_per_second = heartflow_config.get("default_decay_rate_per_second", config.default_decay_rate_per_second) + config.initial_duration = heartflow_config.get("initial_duration", config.initial_duration) def willing(parent: dict): willing_config = parent["willing"] diff --git a/src/heart_flow/heartflow.py b/src/heart_flow/heartflow.py index 5d53a07d..c2f922ff 100644 --- a/src/heart_flow/heartflow.py +++ b/src/heart_flow/heartflow.py @@ -1,5 +1,4 @@ -from .sub_heartflow import SubHeartflow -from .observation import ChattingObservation +from .sub_heartflow import SubHeartflow, ChattingObservation from src.plugins.moods.moods import MoodManager from src.plugins.models.utils_model import LLMRequest from src.config.config import global_config @@ -10,7 +9,8 @@ from src.common.logger import get_module_logger, LogConfig, HEARTFLOW_STYLE_CONF from src.individuality.individuality import Individuality import time import random -from typing import Dict, Any +from typing import Dict, Any, Optional +import traceback heartflow_config = LogConfig( # 使用海马体专用样式 @@ -70,20 +70,27 @@ class Heartflow: """定期清理不活跃的子心流""" while True: current_time = time.time() - inactive_subheartflows = [] + inactive_subheartflows_ids = [] # 修改变量名以清晰表示存储的是ID # 检查所有子心流 - for subheartflow_id, subheartflow in self._subheartflows.items(): + # 使用 list(self._subheartflows.items()) 避免在迭代时修改字典 + for subheartflow_id, subheartflow in list(self._subheartflows.items()): if ( current_time - subheartflow.last_active_time > global_config.sub_heart_flow_stop_time ): # 10分钟 = 600秒 - inactive_subheartflows.append(subheartflow_id) - logger.info(f"发现不活跃的子心流: {subheartflow_id}") + logger.info(f"发现不活跃的子心流: {subheartflow_id}, 准备清理。") + # 1. 标记子心流让其后台任务停止 + subheartflow.should_stop = True + # 2. 将ID添加到待清理列表 + inactive_subheartflows_ids.append(subheartflow_id) - # 清理不活跃的子心流 - for subheartflow_id in inactive_subheartflows: - del self._subheartflows[subheartflow_id] - logger.info(f"已清理不活跃的子心流: {subheartflow_id}") + # 清理不活跃的子心流 (从字典中移除) + for subheartflow_id in inactive_subheartflows_ids: + if subheartflow_id in self._subheartflows: + del self._subheartflows[subheartflow_id] + logger.info(f"已从主心流移除子心流: {subheartflow_id}") + else: + logger.warning(f"尝试移除子心流 {subheartflow_id} 时发现其已被移除。") await asyncio.sleep(30) # 每分钟检查一次 @@ -95,8 +102,10 @@ class Heartflow: await asyncio.sleep(30) # 每分钟检查一次是否有新的子心流 continue - await self.do_a_thinking() - await asyncio.sleep(global_config.heart_flow_update_interval * 3) # 5分钟思考一次 + # await self.do_a_thinking() + # await asyncio.sleep(global_config.heart_flow_update_interval * 3) # 5分钟思考一次 + + await asyncio.sleep(300) async def heartflow_start_working(self): # 启动清理任务 @@ -216,33 +225,55 @@ class Heartflow: return response - async def create_subheartflow(self, subheartflow_id): - """ - 创建一个新的SubHeartflow实例 - 添加一个SubHeartflow实例到self._subheartflows字典中 - 并根据subheartflow_id为子心流创建一个观察对象 + async def create_subheartflow(self, subheartflow_id: Any) -> Optional[SubHeartflow]: """ + 获取或创建一个新的SubHeartflow实例。 + 如果实例已存在，则直接返回。 + 如果不存在，则创建实例、观察对象、启动后台任务，并返回新实例。 + 创建过程中发生任何错误将返回 None。 + + Args: + subheartflow_id: 用于标识子心流的ID (例如群聊ID)。 + + Returns: + 对应的 SubHeartflow 实例，如果创建失败则返回 None。 + """ + # 检查是否已存在 + existing_subheartflow = self._subheartflows.get(subheartflow_id) + if existing_subheartflow: + logger.debug(f"返回已存在的 subheartflow: {subheartflow_id}") + return existing_subheartflow + + # 如果不存在，则创建新的 + logger.info(f"尝试创建新的 subheartflow: {subheartflow_id}") try: - if subheartflow_id not in self._subheartflows: - subheartflow = SubHeartflow(subheartflow_id) - # 创建一个观察对象，目前只可以用chat_id创建观察对象 - logger.debug(f"创建 observation: {subheartflow_id}") - observation = ChattingObservation(subheartflow_id) - await observation.initialize() - subheartflow.add_observation(observation) - logger.debug("添加 observation 成功") - # 创建异步任务 - asyncio.create_task(subheartflow.subheartflow_start_working()) - logger.debug("创建异步任务 成功") - self._subheartflows[subheartflow_id] = subheartflow - logger.info("添加 subheartflow 成功") - return self._subheartflows[subheartflow_id] + subheartflow = SubHeartflow(subheartflow_id) + + # 创建并初始化观察对象 + logger.debug(f"为 {subheartflow_id} 创建 observation") + observation = ChattingObservation(subheartflow_id) + await observation.initialize() # 等待初始化完成 + subheartflow.add_observation(observation) + logger.debug(f"为 {subheartflow_id} 添加 observation 成功") + + # 创建并存储后台任务 + subheartflow.task = asyncio.create_task(subheartflow.subheartflow_start_working()) + logger.debug(f"为 {subheartflow_id} 创建后台任务成功") + + # 添加到管理字典 + self._subheartflows[subheartflow_id] = subheartflow + logger.info(f"添加 subheartflow {subheartflow_id} 成功") + return subheartflow + except Exception as e: - logger.error(f"创建 subheartflow 失败: {e}") + # 记录详细错误信息 + logger.error(f"创建 subheartflow {subheartflow_id} 失败: {e}") + logger.error(traceback.format_exc()) # 记录完整的 traceback + # 考虑是否需要更具体的错误处理或资源清理逻辑 return None - def get_subheartflow(self, observe_chat_id) -> SubHeartflow: + def get_subheartflow(self, observe_chat_id: Any) -> Optional[SubHeartflow]: """获取指定ID的SubHeartflow实例""" return self._subheartflows.get(observe_chat_id) diff --git a/src/heart_flow/sub_heartflow.py b/src/heart_flow/sub_heartflow.py index 439b2a3f..c1a58dcd 100644 --- a/src/heart_flow/sub_heartflow.py +++ b/src/heart_flow/sub_heartflow.py @@ -4,7 +4,7 @@ from src.plugins.moods.moods import MoodManager from src.plugins.models.utils_model import LLMRequest from src.config.config import global_config import time -from typing import Optional +from typing import Optional, List from datetime import datetime import traceback from src.plugins.chat.utils import parse_text_timestamps @@ -65,7 +65,7 @@ class SubHeartflow: def __init__(self, subheartflow_id): self.subheartflow_id = subheartflow_id - self.current_mind = "" + self.current_mind = "你什么也没想" self.past_mind = [] self.current_state: CurrentState = CurrentState() self.llm_model = LLMRequest( @@ -76,16 +76,14 @@ class SubHeartflow: ) self.main_heartflow_info = "" - - self.last_reply_time = time.time() + self.last_active_time = time.time() # 添加最后激活时间 - - if not self.current_mind: - self.current_mind = "你什么也没想" + self.should_stop = False # 添加停止标志 + self.task: Optional[asyncio.Task] = None # 添加 task 属性 self.is_active = False - self.observations: list[ChattingObservation] = [] + self.observations: List[ChattingObservation] = [] # 使用 List 类型提示 self.running_knowledges = [] @@ -93,20 +91,14 @@ class SubHeartflow: async def subheartflow_start_working(self): while True: - current_time = time.time() # --- 调整后台任务逻辑 --- # # 这个后台循环现在主要负责检查是否需要自我销毁 # 不再主动进行思考或状态更新，这些由 HeartFC_Chat 驱动 - # 检查是否超过指定时间没有激活 (例如，没有被调用进行思考) - if current_time - self.last_active_time > global_config.sub_heart_flow_stop_time: # 例如 5 分钟 - logger.info( - f"子心流 {self.subheartflow_id} 超过 {global_config.sub_heart_flow_stop_time} 秒没有激活，正在销毁..." - f" (Last active: {datetime.fromtimestamp(self.last_active_time).strftime('%Y-%m-%d %H:%M:%S')})" - ) - # 在这里添加实际的销毁逻辑，例如从主 Heartflow 管理器中移除自身 - # heartflow.remove_subheartflow(self.subheartflow_id) # 假设有这样的方法 - break # 退出循环以停止任务 + # 检查是否被主心流标记为停止 + if self.should_stop: + logger.info(f"子心流 {self.subheartflow_id} 被标记为停止，正在退出后台任务...") + break # 退出循环以停止任务 await asyncio.sleep(global_config.sub_heart_flow_update_interval) # 定期检查销毁条件 diff --git a/src/plugins/chat/bot.py b/src/plugins/chat/bot.py index 314d20ff..c3ba78b0 100644 --- a/src/plugins/chat/bot.py +++ b/src/plugins/chat/bot.py @@ -105,53 +105,26 @@ class ChatBot: template_group_name = None async def preprocess(): - if global_config.enable_pfc_chatting: - try: - if groupinfo is None: - if global_config.enable_friend_chat: - userinfo = message.message_info.user_info - messageinfo = message.message_info - # 创建聊天流 - chat = await chat_manager.get_or_create_stream( - platform=messageinfo.platform, - user_info=userinfo, - group_info=groupinfo, - ) - message.update_chat_stream(chat) - await self.only_process_chat.process_message(message) - await self._create_pfc_chat(message) + if groupinfo is None: + if global_config.enable_friend_chat: + if global_config.enable_pfc_chatting: + userinfo = message.message_info.user_info + messageinfo = message.message_info + # 创建聊天流 + chat = await chat_manager.get_or_create_stream( + platform=messageinfo.platform, + user_info=userinfo, + group_info=groupinfo, + ) + message.update_chat_stream(chat) + await self.only_process_chat.process_message(message) + await self._create_pfc_chat(message) else: - if groupinfo.group_id in global_config.talk_allowed_groups: - # logger.debug(f"开始群聊模式{str(message_data)[:50]}...") - if global_config.response_mode == "heart_flow": - # logger.info(f"启动最新最好的思维流FC模式{str(message_data)[:50]}...") - await self.heartFC_processor.process_message(message_data) - elif global_config.response_mode == "reasoning": - # logger.debug(f"开始推理模式{str(message_data)[:50]}...") - await self.reasoning_chat.process_message(message_data) - else: - logger.error(f"未知的回复模式，请检查配置文件！！: {global_config.response_mode}") - except Exception as e: - logger.error(f"处理PFC消息失败: {e}") + await self.heartFC_processor.process_message(message_data) else: - if groupinfo is None: - if global_config.enable_friend_chat: - # 私聊处理流程 - # await self._handle_private_chat(message) - if global_config.response_mode == "heart_flow": - await self.heartFC_processor.process_message(message_data) - elif global_config.response_mode == "reasoning": - await self.reasoning_chat.process_message(message_data) - else: - logger.error(f"未知的回复模式，请检查配置文件！！: {global_config.response_mode}") - else: # 群聊处理 - if groupinfo.group_id in global_config.talk_allowed_groups: - if global_config.response_mode == "heart_flow": - await self.heartFC_processor.process_message(message_data) - elif global_config.response_mode == "reasoning": - await self.reasoning_chat.process_message(message_data) - else: - logger.error(f"未知的回复模式，请检查配置文件！！: {global_config.response_mode}") + await self.heartFC_processor.process_message(message_data) + + if template_group_name: async with global_prompt_manager.async_message_scope(template_group_name): diff --git a/src/plugins/chat_module/heartFC_chat/pf_chatting.py b/src/plugins/chat_module/heartFC_chat/pf_chatting.py index 59472fd1..7e6acd53 100644 --- a/src/plugins/chat_module/heartFC_chat/pf_chatting.py +++ b/src/plugins/chat_module/heartFC_chat/pf_chatting.py @@ -15,6 +15,9 @@ from src.config.config import global_config from src.plugins.chat.utils_image import image_path_to_base64 # Local import needed after move from src.plugins.utils.timer_calculater import Timer # <--- Import Timer +INITIAL_DURATION = 60.0 + + # 定义日志配置 (使用 loguru 格式) interest_log_config = LogConfig( console_format=PFC_STYLE_CONFIG["console_format"], # 使用默认控制台格式 @@ -91,7 +94,7 @@ class PFChatting: self._loop_active: bool = False # Is the loop currently running? self._loop_task: Optional[asyncio.Task] = None # Stores the main loop task self._trigger_count_this_activation: int = 0 # Counts triggers within an active period - self._initial_duration: float = 60.0 # 首次触发增加的时间 + self._initial_duration: float = INITIAL_DURATION # 首次触发增加的时间 self._last_added_duration: float = self._initial_duration # <--- 新增：存储上次增加的时间 def _get_log_prefix(self) -> str: diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index 3ebf1459..e4e2a2a8 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,8 +1,7 @@ [inner] version = "1.4.0" - -#以下是给开发人员阅读的，一般用户不需要阅读 +#----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读---- #如果你想要修改配置文件，请在修改后将version的值进行变更 #如果新增项目，请在BotConfig类下新增相应的变量 #1.如果你修改的是[]层级项目，例如你新增了 [memory],那么请在config.py的 load_config函数中的include_configs字典中新增"内容":{ @@ -19,11 +18,12 @@ version = "1.4.0" # 次版本号：当你做了向下兼容的功能性新增， # 修订号：当你做了向下兼容的问题修正。 # 先行版本号及版本编译信息可以加到“主版本号.次版本号.修订号”的后面，作为延伸。 +#----以上是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读---- [bot] -qq = 114514 +qq = 1145141919810 nickname = "麦麦" -alias_names = ["麦叠", "牢麦"] +alias_names = ["麦叠", "牢麦"] #该选项还在调试中，暂时未生效 [groups] talk_allowed = [ @@ -41,23 +41,24 @@ personality_sides = [ "用一句话或几句话描述人格的一些细节", "用一句话或几句话描述人格的一些细节", "用一句话或几句话描述人格的一些细节", -]# 条数任意 +]# 条数任意，不能为0, 该选项还在调试中，可能未完全生效 [identity] #アイデンティティがない 生まれないらららら # 兴趣爱好 未完善，有些条目未使用 identity_detail = [ "身份特点", "身份特点", -]# 条数任意 +]# 条数任意，不能为0, 该选项还在调试中，可能未完全生效 #外貌特征 -height = 170 # 身高 单位厘米 -weight = 50 # 体重 单位千克 -age = 20 # 年龄 单位岁 -gender = "男" # 性别 -appearance = "用几句话描述外貌特征" # 外貌特征 +height = 170 # 身高 单位厘米 该选项还在调试中，暂时未生效 +weight = 50 # 体重 单位千克 该选项还在调试中，暂时未生效 +age = 20 # 年龄 单位岁 该选项还在调试中，暂时未生效 +gender = "男" # 性别 该选项还在调试中，暂时未生效 +appearance = "用几句话描述外貌特征" # 外貌特征 该选项还在调试中，暂时未生效 [schedule] -enable_schedule_gen = true # 是否启用日程表(尚未完成) +enable_schedule_gen = true # 是否启用日程表 +enable_schedule_interaction = true # 日程表是否影响回复模式 prompt_schedule_gen = "用几句话描述描述性格特点或行动规律，这个特征会用来生成日程表" schedule_doing_update_interval = 900 # 日程表更新间隔 单位秒 schedule_temperature = 0.1 # 日程表温度，建议0.1-0.5 @@ -67,19 +68,25 @@ time_zone = "Asia/Shanghai" # 给你的机器人设置时区，可以解决运 nonebot-qq="http://127.0.0.1:18002/api/message" [response] #群聊的回复策略 -#reasoning：推理模式，麦麦会根据上下文进行推理，并给出回复 -#heart_flow：结合了PFC模式和心流模式，麦麦会进行主动的观察和回复，并给出回复 -response_mode = "heart_flow" # 回复策略，可选值：heart_flow（心流），reasoning（推理) +enable_heart_flowC = true +# 该功能还在完善中 +# 是否启用heart_flowC(心流聊天,HFC)模式 +# 启用后麦麦会自主选择进入heart_flowC模式(持续一段时间），进行主动的观察和回复，并给出回复，比较消耗token -#推理回复参数 -model_r1_probability = 0.7 # 麦麦回答时选择主要回复模型1 模型的概率 -model_v3_probability = 0.3 # 麦麦回答时选择次要回复模型2 模型的概率 +#一般回复参数 +model_reasoning_probability = 0.7 # 麦麦回答时选择推理模型 模型的概率 +model_normal_probability = 0.3 # 麦麦回答时选择一般模型 模型的概率 + +[heartflow] #启用启用heart_flowC(心流聊天)模式时生效，需要填写以下参数 +reply_trigger_threshold = 3.0 # 心流聊天触发阈值，越低越容易进入心流聊天 +probability_decay_factor_per_second = 0.2 # 概率衰减因子，越大衰减越快，越高越容易退出心流聊天 +default_decay_rate_per_second = 0.98 # 默认衰减率，越大衰减越快，越高越难进入心流聊天 +initial_duration = 60 # 初始持续时间，越大心流聊天持续的时间越长 -[heartflow] # 注意：可能会消耗大量token，请谨慎开启，仅会使用v3模型 -sub_heart_flow_update_interval = 60 # 子心流更新频率，间隔 单位秒 -sub_heart_flow_freeze_time = 100 # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒 sub_heart_flow_stop_time = 500 # 子心流停止时间，超过这个时间没有回复，子心流会停止，间隔 单位秒 -heart_flow_update_interval = 600 # 心流更新频率，间隔 单位秒 +# sub_heart_flow_update_interval = 60 +# sub_heart_flow_freeze_time = 100 +# heart_flow_update_interval = 600 observation_context_size = 20 # 心流观察到的最长上下文大小，超过这个值的上下文会被压缩 compressed_length = 5 # 不能大于observation_context_size,心流上下文压缩的最短压缩长度，超过心流观察到的上下文长度，会压缩，最短压缩长度为5 @@ -87,11 +94,13 @@ compress_length_limit = 5 #最多压缩份数，超过该数值的压缩上下 [message] -max_context_size = 12 # 麦麦获得的上文数量，建议12，太短太长都会导致脑袋尖尖 -emoji_chance = 0.2 # 麦麦使用表情包的概率，设置为1让麦麦自己决定发不发 -thinking_timeout = 60 # 麦麦最长思考时间，超过这个时间的思考会放弃 -max_response_length = 256 # 麦麦回答的最大token数 +max_context_size = 12 # 麦麦回复时获得的上文数量，建议12，太短太长都会导致脑袋尖尖 +emoji_chance = 0.2 # 麦麦一般回复时使用表情包的概率，设置为1让麦麦自己决定发不发 +thinking_timeout = 100 # 麦麦最长思考时间，超过这个时间的思考会放弃（往往是api反应太慢） +max_response_length = 256 # 麦麦单次回答的最大token数 message_buffer = true # 启用消息缓冲器？启用此项以解决消息的拆分问题，但会使麦麦的回复延迟 + +# 以下是消息过滤，可以根据规则过滤特定消息，将不会读取这些消息 ban_words = [ # "403","张三" ] @@ -103,22 +112,23 @@ ban_msgs_regex = [ # "\\[CQ:at,qq=\\d+\\]" # 匹配@ ] -[willing] +[willing] # 一般回复模式的回复意愿设置 willing_mode = "classical" # 回复意愿模式 —— 经典模式：classical，动态模式：dynamic，mxp模式：mxp，自定义模式：custom（需要你自己实现） response_willing_amplifier = 1 # 麦麦回复意愿放大系数，一般为1 response_interested_rate_amplifier = 1 # 麦麦回复兴趣度放大系数,听到记忆里的内容时放大系数 down_frequency_rate = 3 # 降低回复频率的群组回复意愿降低系数 除法 -emoji_response_penalty = 0.1 # 表情包回复惩罚系数，设为0为不回复单个表情包，减少单独回复表情包的概率 +emoji_response_penalty = 0 # 表情包回复惩罚系数，设为0为不回复单个表情包，减少单独回复表情包的概率 mentioned_bot_inevitable_reply = false # 提及 bot 必然回复 at_bot_inevitable_reply = false # @bot 必然回复 [emoji] -max_emoji_num = 120 # 表情包最大数量 +max_emoji_num = 90 # 表情包最大数量 max_reach_deletion = true # 开启则在达到最大数量时删除表情包，关闭则达到最大数量时不删除，只是不会继续收集表情包 check_interval = 30 # 检查表情包（注册，破损，删除）的时间间隔(分钟) auto_save = true # 是否保存表情包和图片 -enable_check = false # 是否启用表情包过滤 -check_prompt = "符合公序良俗" # 表情包过滤要求 + +enable_check = false # 是否启用表情包过滤，只有符合该要求的表情包才会被保存 +check_prompt = "符合公序良俗" # 表情包过滤要求，只有符合该要求的表情包才会被保存 [memory] build_memory_interval = 2000 # 记忆构建间隔 单位秒 间隔越低，麦麦学习越多，但是冗余信息也会增多 @@ -131,7 +141,8 @@ forget_memory_interval = 1000 # 记忆遗忘间隔 单位秒 间隔越低， memory_forget_time = 24 #多长时间后的记忆会被遗忘 单位小时 memory_forget_percentage = 0.01 # 记忆遗忘比例 控制记忆遗忘程度 越大遗忘越多 建议保持默认 -memory_ban_words = [ #不希望记忆的词 +#不希望记忆的词，已经记忆的不会受到影响 +memory_ban_words = [ # "403","张三" ] @@ -167,7 +178,7 @@ word_replace_rate=0.006 # 整词替换概率 [response_splitter] enable_response_splitter = true # 是否启用回复分割器 -response_max_length = 100 # 回复允许的最大长度 +response_max_length = 256 # 回复允许的最大长度 response_max_sentence_num = 4 # 回复允许的最大句子数 [remote] #发送统计信息，主要是看全球有多少只麦麦 From 388392b9c515dcdfb1f3697ef8020a5b2574ff1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 14:16:13 +0900 Subject: [PATCH 06/26] =?UTF-8?q?fix:=20=E5=88=A0=E9=99=A4=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E7=9A=84=E7=B1=BB=E5=AE=9A=E4=B9=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/memory_system/Hippocampus.py | 995 +++++++---------------- 1 file changed, 281 insertions(+), 714 deletions(-) diff --git a/src/plugins/memory_system/Hippocampus.py b/src/plugins/memory_system/Hippocampus.py index 557b42f2..f25f1d45 100644 --- a/src/plugins/memory_system/Hippocampus.py +++ b/src/plugins/memory_system/Hippocampus.py @@ -342,720 +342,6 @@ class Hippocampus: memories.sort(key=lambda x: x[2], reverse=True) return memories - async def get_memory_from_text( - self, - text: str, - max_memory_num: int = 3, - max_memory_length: int = 2, - max_depth: int = 3, - fast_retrieval: bool = False, - ) -> list: - """从文本中提取关键词并获取相关记忆。 - - Args: - text (str): 输入文本 - max_memory_num (int, optional): 记忆数量限制。默认为3。 - max_memory_length (int, optional): 记忆长度限制。默认为2。 - max_depth (int, optional): 记忆检索深度。默认为2。 - fast_retrieval (bool, optional): 是否使用快速检索。默认为False。 - 如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。 - 如果为False，使用LLM提取关键词，速度较慢但更准确。 - - Returns: - list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity) - - topic: str, 记忆主题 - - memory_items: list, 该主题下的记忆项列表 - - similarity: float, 与文本的相似度 - """ - if not text: - return [] - - if fast_retrieval: - # 使用jieba分词提取关键词 - words = jieba.cut(text) - # 过滤掉停用词和单字词 - keywords = [word for word in words if len(word) > 1] - # 去重 - keywords = list(set(keywords)) - # 限制关键词数量 - keywords = keywords[:5] - else: - # 使用LLM提取关键词 - topic_num = min(5, max(1, int(len(text) * 0.1))) # 根据文本长度动态调整关键词数量 - # logger.info(f"提取关键词数量: {topic_num}") - topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num)) - - # 提取关键词 - keywords = re.findall(r"<([^>]+)>", topics_response[0]) - if not keywords: - keywords = [] - else: - keywords = [ - keyword.strip() - for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",") - if keyword.strip() - ] - - # logger.info(f"提取的关键词: {', '.join(keywords)}") - - # 过滤掉不存在于记忆图中的关键词 - valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G] - if not valid_keywords: - # logger.info("没有找到有效的关键词节点") - return [] - - logger.info(f"有效的关键词: {', '.join(valid_keywords)}") - - # 从每个关键词获取记忆 - all_memories = [] - activate_map = {} # 存储每个词的累计激活值 - - # 对每个关键词进行扩散式检索 - for keyword in valid_keywords: - logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):") - # 初始化激活值 - activation_values = {keyword: 1.0} - # 记录已访问的节点 - visited_nodes = {keyword} - # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度) - nodes_to_process = [(keyword, 1.0, 0)] - - while nodes_to_process: - current_node, current_activation, current_depth = nodes_to_process.pop(0) - - # 如果激活值小于0或超过最大深度，停止扩散 - if current_activation <= 0 or current_depth >= max_depth: - continue - - # 获取当前节点的所有邻居 - neighbors = list(self.memory_graph.G.neighbors(current_node)) - - for neighbor in neighbors: - if neighbor in visited_nodes: - continue - - # 获取连接强度 - edge_data = self.memory_graph.G[current_node][neighbor] - strength = edge_data.get("strength", 1) - - # 计算新的激活值 - new_activation = current_activation - (1 / strength) - - if new_activation > 0: - activation_values[neighbor] = new_activation - visited_nodes.add(neighbor) - nodes_to_process.append((neighbor, new_activation, current_depth + 1)) - logger.trace( - f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})" - ) # noqa: E501 - - # 更新激活映射 - for node, activation_value in activation_values.items(): - if activation_value > 0: - if node in activate_map: - activate_map[node] += activation_value - else: - activate_map[node] = activation_value - - # 输出激活映射 - # logger.info("激活映射统计:") - # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True): - # logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}") - - # 基于激活值平方的独立概率选择 - remember_map = {} - # logger.info("基于激活值平方的归一化选择:") - - # 计算所有激活值的平方和 - total_squared_activation = sum(activation**2 for activation in activate_map.values()) - if total_squared_activation > 0: - # 计算归一化的激活值 - normalized_activations = { - node: (activation**2) / total_squared_activation for node, activation in activate_map.items() - } - - # 按归一化激活值排序并选择前max_memory_num个 - sorted_nodes = sorted(normalized_activations.items(), key=lambda x: x[1], reverse=True)[:max_memory_num] - - # 将选中的节点添加到remember_map - for node, normalized_activation in sorted_nodes: - remember_map[node] = activate_map[node] # 使用原始激活值 - logger.debug( - f"节点 '{node}' (归一化激活值: {normalized_activation:.2f}, 激活值: {activate_map[node]:.2f})" - ) - else: - logger.info("没有有效的激活值") - - # 从选中的节点中提取记忆 - all_memories = [] - # logger.info("开始从选中的节点中提取记忆:") - for node, activation in remember_map.items(): - logger.debug(f"处理节点 '{node}' (激活值: {activation:.2f}):") - node_data = self.memory_graph.G.nodes[node] - memory_items = node_data.get("memory_items", []) - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - - if memory_items: - logger.debug(f"节点包含 {len(memory_items)} 条记忆") - # 计算每条记忆与输入文本的相似度 - memory_similarities = [] - for memory in memory_items: - # 计算与输入文本的相似度 - memory_words = set(jieba.cut(memory)) - text_words = set(jieba.cut(text)) - all_words = memory_words | text_words - v1 = [1 if word in memory_words else 0 for word in all_words] - v2 = [1 if word in text_words else 0 for word in all_words] - similarity = cosine_similarity(v1, v2) - memory_similarities.append((memory, similarity)) - - # 按相似度排序 - memory_similarities.sort(key=lambda x: x[1], reverse=True) - # 获取最匹配的记忆 - top_memories = memory_similarities[:max_memory_length] - - # 添加到结果中 - for memory, similarity in top_memories: - all_memories.append((node, [memory], similarity)) - # logger.info(f"选中记忆: {memory} (相似度: {similarity:.2f})") - else: - logger.info("节点没有记忆") - - # 去重（基于记忆内容） - logger.debug("开始记忆去重:") - seen_memories = set() - unique_memories = [] - for topic, memory_items, activation_value in all_memories: - memory = memory_items[0] # 因为每个topic只有一条记忆 - if memory not in seen_memories: - seen_memories.add(memory) - unique_memories.append((topic, memory_items, activation_value)) - logger.debug(f"保留记忆: {memory} (来自节点: {topic}, 激活值: {activation_value:.2f})") - else: - logger.debug(f"跳过重复记忆: {memory} (来自节点: {topic})") - - # 转换为(关键词, 记忆)格式 - result = [] - for topic, memory_items, _ in unique_memories: - memory = memory_items[0] # 因为每个topic只有一条记忆 - result.append((topic, memory)) - logger.info(f"选中记忆: {memory} (来自节点: {topic})") - - return result - - async def get_activate_from_text(self, text: str, max_depth: int = 3, fast_retrieval: bool = False) -> float: - """从文本中提取关键词并获取相关记忆。 - - Args: - text (str): 输入文本 - max_depth (int, optional): 记忆检索深度。默认为2。 - fast_retrieval (bool, optional): 是否使用快速检索。默认为False。 - 如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。 - 如果为False，使用LLM提取关键词，速度较慢但更准确。 - - Returns: - float: 激活节点数与总节点数的比值 - """ - if not text: - return 0 - - if fast_retrieval: - # 使用jieba分词提取关键词 - words = jieba.cut(text) - # 过滤掉停用词和单字词 - keywords = [word for word in words if len(word) > 1] - # 去重 - keywords = list(set(keywords)) - # 限制关键词数量 - keywords = keywords[:5] - else: - # 使用LLM提取关键词 - topic_num = min(5, max(1, int(len(text) * 0.1))) # 根据文本长度动态调整关键词数量 - # logger.info(f"提取关键词数量: {topic_num}") - topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num)) - - # 提取关键词 - keywords = re.findall(r"<([^>]+)>", topics_response[0]) - if not keywords: - keywords = [] - else: - keywords = [ - keyword.strip() - for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",") - if keyword.strip() - ] - - # logger.info(f"提取的关键词: {', '.join(keywords)}") - - # 过滤掉不存在于记忆图中的关键词 - valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G] - if not valid_keywords: - # logger.info("没有找到有效的关键词节点") - return 0 - - logger.info(f"有效的关键词: {', '.join(valid_keywords)}") - - # 从每个关键词获取记忆 - activate_map = {} # 存储每个词的累计激活值 - - # 对每个关键词进行扩散式检索 - for keyword in valid_keywords: - logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):") - # 初始化激活值 - activation_values = {keyword: 1.0} - # 记录已访问的节点 - visited_nodes = {keyword} - # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度) - nodes_to_process = [(keyword, 1.0, 0)] - - while nodes_to_process: - current_node, current_activation, current_depth = nodes_to_process.pop(0) - - # 如果激活值小于0或超过最大深度，停止扩散 - if current_activation <= 0 or current_depth >= max_depth: - continue - - # 获取当前节点的所有邻居 - neighbors = list(self.memory_graph.G.neighbors(current_node)) - - for neighbor in neighbors: - if neighbor in visited_nodes: - continue - - # 获取连接强度 - edge_data = self.memory_graph.G[current_node][neighbor] - strength = edge_data.get("strength", 1) - - # 计算新的激活值 - new_activation = current_activation - (1 / strength) - - if new_activation > 0: - activation_values[neighbor] = new_activation - visited_nodes.add(neighbor) - nodes_to_process.append((neighbor, new_activation, current_depth + 1)) - # logger.debug( - # f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})") # noqa: E501 - - # 更新激活映射 - for node, activation_value in activation_values.items(): - if activation_value > 0: - if node in activate_map: - activate_map[node] += activation_value - else: - activate_map[node] = activation_value - - # 输出激活映射 - # logger.info("激活映射统计:") - # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True): - # logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}") - - # 计算激活节点数与总节点数的比值 - total_activation = sum(activate_map.values()) - logger.info(f"总激活值: {total_activation:.2f}") - total_nodes = len(self.memory_graph.G.nodes()) - # activated_nodes = len(activate_map) - activation_ratio = total_activation / total_nodes if total_nodes > 0 else 0 - activation_ratio = activation_ratio * 60 - logger.info(f"总激活值: {total_activation:.2f}, 总节点数: {total_nodes}, 激活: {activation_ratio}") - - return activation_ratio - - -# 负责海马体与其他部分的交互 -class EntorhinalCortex: - def __init__(self, hippocampus: Hippocampus): - self.hippocampus = hippocampus - self.memory_graph = hippocampus.memory_graph - self.config = hippocampus.config - - def get_memory_sample(self): - """从数据库获取记忆样本""" - # 硬编码：每条消息最大记忆次数 - max_memorized_time_per_msg = 3 - - # 创建双峰分布的记忆调度器 - sample_scheduler = MemoryBuildScheduler( - n_hours1=self.config.memory_build_distribution[0], - std_hours1=self.config.memory_build_distribution[1], - weight1=self.config.memory_build_distribution[2], - n_hours2=self.config.memory_build_distribution[3], - std_hours2=self.config.memory_build_distribution[4], - weight2=self.config.memory_build_distribution[5], - total_samples=self.config.build_memory_sample_num, - ) - - timestamps = sample_scheduler.get_timestamp_array() - logger.info(f"回忆往事: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}") - chat_samples = [] - for timestamp in timestamps: - messages = self.random_get_msg_snippet( - timestamp, self.config.build_memory_sample_length, max_memorized_time_per_msg - ) - if messages: - time_diff = (datetime.datetime.now().timestamp() - timestamp) / 3600 - logger.debug(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条") - chat_samples.append(messages) - else: - logger.debug(f"时间戳 {timestamp} 的消息样本抽取失败") - - return chat_samples - - @staticmethod - def random_get_msg_snippet(target_timestamp: float, chat_size: int, max_memorized_time_per_msg: int) -> list: - """从数据库中随机获取指定时间戳附近的消息片段""" - try_count = 0 - while try_count < 3: - messages = get_closest_chat_from_db(length=chat_size, timestamp=target_timestamp) - if messages: - for message in messages: - if message["memorized_times"] >= max_memorized_time_per_msg: - messages = None - break - if messages: - for message in messages: - db.messages.update_one( - {"_id": message["_id"]}, {"$set": {"memorized_times": message["memorized_times"] + 1}} - ) - return messages - try_count += 1 - return None - - async def sync_memory_to_db(self): - """将记忆图同步到数据库""" - # 获取数据库中所有节点和内存中所有节点 - db_nodes = list(db.graph_data.nodes.find()) - memory_nodes = list(self.memory_graph.G.nodes(data=True)) - - # 转换数据库节点为字典格式,方便查找 - db_nodes_dict = {node["concept"]: node for node in db_nodes} - - # 检查并更新节点 - for concept, data in memory_nodes: - memory_items = data.get("memory_items", []) - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - - # 计算内存中节点的特征值 - memory_hash = self.hippocampus.calculate_node_hash(concept, memory_items) - - # 获取时间信息 - created_time = data.get("created_time", datetime.datetime.now().timestamp()) - last_modified = data.get("last_modified", datetime.datetime.now().timestamp()) - - if concept not in db_nodes_dict: - # 数据库中缺少的节点,添加 - node_data = { - "concept": concept, - "memory_items": memory_items, - "hash": memory_hash, - "created_time": created_time, - "last_modified": last_modified, - } - db.graph_data.nodes.insert_one(node_data) - else: - # 获取数据库中节点的特征值 - db_node = db_nodes_dict[concept] - db_hash = db_node.get("hash", None) - - # 如果特征值不同,则更新节点 - if db_hash != memory_hash: - db.graph_data.nodes.update_one( - {"concept": concept}, - { - "$set": { - "memory_items": memory_items, - "hash": memory_hash, - "created_time": created_time, - "last_modified": last_modified, - } - }, - ) - - # 处理边的信息 - db_edges = list(db.graph_data.edges.find()) - memory_edges = list(self.memory_graph.G.edges(data=True)) - - # 创建边的哈希值字典 - db_edge_dict = {} - for edge in db_edges: - edge_hash = self.hippocampus.calculate_edge_hash(edge["source"], edge["target"]) - db_edge_dict[(edge["source"], edge["target"])] = {"hash": edge_hash, "strength": edge.get("strength", 1)} - - # 检查并更新边 - for source, target, data in memory_edges: - edge_hash = self.hippocampus.calculate_edge_hash(source, target) - edge_key = (source, target) - strength = data.get("strength", 1) - - # 获取边的时间信息 - created_time = data.get("created_time", datetime.datetime.now().timestamp()) - last_modified = data.get("last_modified", datetime.datetime.now().timestamp()) - - if edge_key not in db_edge_dict: - # 添加新边 - edge_data = { - "source": source, - "target": target, - "strength": strength, - "hash": edge_hash, - "created_time": created_time, - "last_modified": last_modified, - } - db.graph_data.edges.insert_one(edge_data) - else: - # 检查边的特征值是否变化 - if db_edge_dict[edge_key]["hash"] != edge_hash: - db.graph_data.edges.update_one( - {"source": source, "target": target}, - { - "$set": { - "hash": edge_hash, - "strength": strength, - "created_time": created_time, - "last_modified": last_modified, - } - }, - ) - - def sync_memory_from_db(self): - """从数据库同步数据到内存中的图结构""" - current_time = datetime.datetime.now().timestamp() - need_update = False - - # 清空当前图 - self.memory_graph.G.clear() - - # 从数据库加载所有节点 - nodes = list(db.graph_data.nodes.find()) - for node in nodes: - concept = node["concept"] - memory_items = node.get("memory_items", []) - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - - # 检查时间字段是否存在 - if "created_time" not in node or "last_modified" not in node: - need_update = True - # 更新数据库中的节点 - update_data = {} - if "created_time" not in node: - update_data["created_time"] = current_time - if "last_modified" not in node: - update_data["last_modified"] = current_time - - db.graph_data.nodes.update_one({"concept": concept}, {"$set": update_data}) - logger.info(f"[时间更新] 节点 {concept} 添加缺失的时间字段") - - # 获取时间信息(如果不存在则使用当前时间) - created_time = node.get("created_time", current_time) - last_modified = node.get("last_modified", current_time) - - # 添加节点到图中 - self.memory_graph.G.add_node( - concept, memory_items=memory_items, created_time=created_time, last_modified=last_modified - ) - - # 从数据库加载所有边 - edges = list(db.graph_data.edges.find()) - for edge in edges: - source = edge["source"] - target = edge["target"] - strength = edge.get("strength", 1) - - # 检查时间字段是否存在 - if "created_time" not in edge or "last_modified" not in edge: - need_update = True - # 更新数据库中的边 - update_data = {} - if "created_time" not in edge: - update_data["created_time"] = current_time - if "last_modified" not in edge: - update_data["last_modified"] = current_time - - db.graph_data.edges.update_one({"source": source, "target": target}, {"$set": update_data}) - logger.info(f"[时间更新] 边 {source} - {target} 添加缺失的时间字段") - - # 获取时间信息(如果不存在则使用当前时间) - created_time = edge.get("created_time", current_time) - last_modified = edge.get("last_modified", current_time) - - # 只有当源节点和目标节点都存在时才添加边 - if source in self.memory_graph.G and target in self.memory_graph.G: - self.memory_graph.G.add_edge( - source, target, strength=strength, created_time=created_time, last_modified=last_modified - ) - - if need_update: - logger.success("[数据库] 已为缺失的时间字段进行补充") - - async def resync_memory_to_db(self): - """清空数据库并重新同步所有记忆数据""" - start_time = time.time() - logger.info("[数据库] 开始重新同步所有记忆数据...") - - # 清空数据库 - clear_start = time.time() - db.graph_data.nodes.delete_many({}) - db.graph_data.edges.delete_many({}) - clear_end = time.time() - logger.info(f"[数据库] 清空数据库耗时: {clear_end - clear_start:.2f}秒") - - # 获取所有节点和边 - memory_nodes = list(self.memory_graph.G.nodes(data=True)) - memory_edges = list(self.memory_graph.G.edges(data=True)) - - # 重新写入节点 - node_start = time.time() - for concept, data in memory_nodes: - memory_items = data.get("memory_items", []) - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - - node_data = { - "concept": concept, - "memory_items": memory_items, - "hash": self.hippocampus.calculate_node_hash(concept, memory_items), - "created_time": data.get("created_time", datetime.datetime.now().timestamp()), - "last_modified": data.get("last_modified", datetime.datetime.now().timestamp()), - } - db.graph_data.nodes.insert_one(node_data) - node_end = time.time() - logger.info(f"[数据库] 写入 {len(memory_nodes)} 个节点耗时: {node_end - node_start:.2f}秒") - - # 重新写入边 - edge_start = time.time() - for source, target, data in memory_edges: - edge_data = { - "source": source, - "target": target, - "strength": data.get("strength", 1), - "hash": self.hippocampus.calculate_edge_hash(source, target), - "created_time": data.get("created_time", datetime.datetime.now().timestamp()), - "last_modified": data.get("last_modified", datetime.datetime.now().timestamp()), - } - db.graph_data.edges.insert_one(edge_data) - edge_end = time.time() - logger.info(f"[数据库] 写入 {len(memory_edges)} 条边耗时: {edge_end - edge_start:.2f}秒") - - end_time = time.time() - logger.success(f"[数据库] 重新同步完成，总耗时: {end_time - start_time:.2f}秒") - logger.success(f"[数据库] 同步了 {len(memory_nodes)} 个节点和 {len(memory_edges)} 条边") - - -# 海马体 -class Hippocampus: - def __init__(self): - self.memory_graph = MemoryGraph() - self.llm_topic_judge = None - self.llm_summary_by_topic = None - self.entorhinal_cortex = None - self.parahippocampal_gyrus = None - self.config = None - - def initialize(self, global_config): - self.config = MemoryConfig.from_global_config(global_config) - # 初始化子组件 - self.entorhinal_cortex = EntorhinalCortex(self) - self.parahippocampal_gyrus = ParahippocampalGyrus(self) - # 从数据库加载记忆图 - self.entorhinal_cortex.sync_memory_from_db() - self.llm_topic_judge = LLMRequest(self.config.llm_topic_judge, request_type="memory") - self.llm_summary_by_topic = LLMRequest(self.config.llm_summary_by_topic, request_type="memory") - - def get_all_node_names(self) -> list: - """获取记忆图中所有节点的名字列表""" - return list(self.memory_graph.G.nodes()) - - @staticmethod - def calculate_node_hash(concept, memory_items) -> int: - """计算节点的特征值""" - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - sorted_items = sorted(memory_items) - content = f"{concept}:{'|'.join(sorted_items)}" - return hash(content) - - @staticmethod - def calculate_edge_hash(source, target) -> int: - """计算边的特征值""" - nodes = sorted([source, target]) - return hash(f"{nodes[0]}:{nodes[1]}") - - @staticmethod - def find_topic_llm(text, topic_num): - prompt = ( - f"这是一段文字：{text}。请你从这段话中总结出最多{topic_num}个关键的概念，可以是名词，动词，或者特定人物，帮我列出来，" - f"将主题用逗号隔开，并加上<>,例如<主题1>,<主题2>......尽可能精简。只需要列举最多{topic_num}个话题就好，不要有序号，不要告诉我其他内容。" - f"如果确定找不出主题或者没有明显主题，返回。" - ) - return prompt - - @staticmethod - def topic_what(text, topic, time_info): - prompt = ( - f'这是一段文字，{time_info}：{text}。我想让你基于这段文字来概括"{topic}"这个概念，帮我总结成一句自然的话，' - f"可以包含时间和人物，以及具体的观点。只输出这句话就好" - ) - return prompt - - @staticmethod - def calculate_topic_num(text, compress_rate): - """计算文本的话题数量""" - information_content = calculate_information_content(text) - topic_by_length = text.count("\n") * compress_rate - topic_by_information_content = max(1, min(5, int((information_content - 3) * 2))) - topic_num = int((topic_by_length + topic_by_information_content) / 2) - logger.debug( - f"topic_by_length: {topic_by_length}, topic_by_information_content: {topic_by_information_content}, " - f"topic_num: {topic_num}" - ) - return topic_num - - def get_memory_from_keyword(self, keyword: str, max_depth: int = 2) -> list: - """从关键词获取相关记忆。 - - Args: - keyword (str): 关键词 - max_depth (int, optional): 记忆检索深度，默认为2。1表示只获取直接相关的记忆，2表示获取间接相关的记忆。 - - Returns: - list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity) - - topic: str, 记忆主题 - - memory_items: list, 该主题下的记忆项列表 - - similarity: float, 与关键词的相似度 - """ - if not keyword: - return [] - - # 获取所有节点 - all_nodes = list(self.memory_graph.G.nodes()) - memories = [] - - # 计算关键词的词集合 - keyword_words = set(jieba.cut(keyword)) - - # 遍历所有节点，计算相似度 - for node in all_nodes: - node_words = set(jieba.cut(node)) - all_words = keyword_words | node_words - v1 = [1 if word in keyword_words else 0 for word in all_words] - v2 = [1 if word in node_words else 0 for word in all_words] - similarity = cosine_similarity(v1, v2) - - # 如果相似度超过阈值，获取该节点的记忆 - if similarity >= 0.3: # 可以调整这个阈值 - node_data = self.memory_graph.G.nodes[node] - memory_items = node_data.get("memory_items", []) - if not isinstance(memory_items, list): - memory_items = [memory_items] if memory_items else [] - - memories.append((node, memory_items, similarity)) - - # 按相似度降序排序 - memories.sort(key=lambda x: x[2], reverse=True) - return memories - async def get_memory_from_text( self, text: str, @@ -1543,6 +829,287 @@ class Hippocampus: return activation_ratio +# 负责海马体与其他部分的交互 +class EntorhinalCortex: + def __init__(self, hippocampus: Hippocampus): + self.hippocampus = hippocampus + self.memory_graph = hippocampus.memory_graph + self.config = hippocampus.config + + def get_memory_sample(self): + """从数据库获取记忆样本""" + # 硬编码：每条消息最大记忆次数 + max_memorized_time_per_msg = 3 + + # 创建双峰分布的记忆调度器 + sample_scheduler = MemoryBuildScheduler( + n_hours1=self.config.memory_build_distribution[0], + std_hours1=self.config.memory_build_distribution[1], + weight1=self.config.memory_build_distribution[2], + n_hours2=self.config.memory_build_distribution[3], + std_hours2=self.config.memory_build_distribution[4], + weight2=self.config.memory_build_distribution[5], + total_samples=self.config.build_memory_sample_num, + ) + + timestamps = sample_scheduler.get_timestamp_array() + logger.info(f"回忆往事: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}") + chat_samples = [] + for timestamp in timestamps: + messages = self.random_get_msg_snippet( + timestamp, self.config.build_memory_sample_length, max_memorized_time_per_msg + ) + if messages: + time_diff = (datetime.datetime.now().timestamp() - timestamp) / 3600 + logger.debug(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条") + chat_samples.append(messages) + else: + logger.debug(f"时间戳 {timestamp} 的消息样本抽取失败") + + return chat_samples + + @staticmethod + def random_get_msg_snippet(target_timestamp: float, chat_size: int, max_memorized_time_per_msg: int) -> list: + """从数据库中随机获取指定时间戳附近的消息片段""" + try_count = 0 + while try_count < 3: + messages = get_closest_chat_from_db(length=chat_size, timestamp=target_timestamp) + if messages: + for message in messages: + if message["memorized_times"] >= max_memorized_time_per_msg: + messages = None + break + if messages: + for message in messages: + db.messages.update_one( + {"_id": message["_id"]}, {"$set": {"memorized_times": message["memorized_times"] + 1}} + ) + return messages + try_count += 1 + return None + + async def sync_memory_to_db(self): + """将记忆图同步到数据库""" + # 获取数据库中所有节点和内存中所有节点 + db_nodes = list(db.graph_data.nodes.find()) + memory_nodes = list(self.memory_graph.G.nodes(data=True)) + + # 转换数据库节点为字典格式,方便查找 + db_nodes_dict = {node["concept"]: node for node in db_nodes} + + # 检查并更新节点 + for concept, data in memory_nodes: + memory_items = data.get("memory_items", []) + if not isinstance(memory_items, list): + memory_items = [memory_items] if memory_items else [] + + # 计算内存中节点的特征值 + memory_hash = self.hippocampus.calculate_node_hash(concept, memory_items) + + # 获取时间信息 + created_time = data.get("created_time", datetime.datetime.now().timestamp()) + last_modified = data.get("last_modified", datetime.datetime.now().timestamp()) + + if concept not in db_nodes_dict: + # 数据库中缺少的节点,添加 + node_data = { + "concept": concept, + "memory_items": memory_items, + "hash": memory_hash, + "created_time": created_time, + "last_modified": last_modified, + } + db.graph_data.nodes.insert_one(node_data) + else: + # 获取数据库中节点的特征值 + db_node = db_nodes_dict[concept] + db_hash = db_node.get("hash", None) + + # 如果特征值不同,则更新节点 + if db_hash != memory_hash: + db.graph_data.nodes.update_one( + {"concept": concept}, + { + "$set": { + "memory_items": memory_items, + "hash": memory_hash, + "created_time": created_time, + "last_modified": last_modified, + } + }, + ) + + # 处理边的信息 + db_edges = list(db.graph_data.edges.find()) + memory_edges = list(self.memory_graph.G.edges(data=True)) + + # 创建边的哈希值字典 + db_edge_dict = {} + for edge in db_edges: + edge_hash = self.hippocampus.calculate_edge_hash(edge["source"], edge["target"]) + db_edge_dict[(edge["source"], edge["target"])] = {"hash": edge_hash, "strength": edge.get("strength", 1)} + + # 检查并更新边 + for source, target, data in memory_edges: + edge_hash = self.hippocampus.calculate_edge_hash(source, target) + edge_key = (source, target) + strength = data.get("strength", 1) + + # 获取边的时间信息 + created_time = data.get("created_time", datetime.datetime.now().timestamp()) + last_modified = data.get("last_modified", datetime.datetime.now().timestamp()) + + if edge_key not in db_edge_dict: + # 添加新边 + edge_data = { + "source": source, + "target": target, + "strength": strength, + "hash": edge_hash, + "created_time": created_time, + "last_modified": last_modified, + } + db.graph_data.edges.insert_one(edge_data) + else: + # 检查边的特征值是否变化 + if db_edge_dict[edge_key]["hash"] != edge_hash: + db.graph_data.edges.update_one( + {"source": source, "target": target}, + { + "$set": { + "hash": edge_hash, + "strength": strength, + "created_time": created_time, + "last_modified": last_modified, + } + }, + ) + + def sync_memory_from_db(self): + """从数据库同步数据到内存中的图结构""" + current_time = datetime.datetime.now().timestamp() + need_update = False + + # 清空当前图 + self.memory_graph.G.clear() + + # 从数据库加载所有节点 + nodes = list(db.graph_data.nodes.find()) + for node in nodes: + concept = node["concept"] + memory_items = node.get("memory_items", []) + if not isinstance(memory_items, list): + memory_items = [memory_items] if memory_items else [] + + # 检查时间字段是否存在 + if "created_time" not in node or "last_modified" not in node: + need_update = True + # 更新数据库中的节点 + update_data = {} + if "created_time" not in node: + update_data["created_time"] = current_time + if "last_modified" not in node: + update_data["last_modified"] = current_time + + db.graph_data.nodes.update_one({"concept": concept}, {"$set": update_data}) + logger.info(f"[时间更新] 节点 {concept} 添加缺失的时间字段") + + # 获取时间信息(如果不存在则使用当前时间) + created_time = node.get("created_time", current_time) + last_modified = node.get("last_modified", current_time) + + # 添加节点到图中 + self.memory_graph.G.add_node( + concept, memory_items=memory_items, created_time=created_time, last_modified=last_modified + ) + + # 从数据库加载所有边 + edges = list(db.graph_data.edges.find()) + for edge in edges: + source = edge["source"] + target = edge["target"] + strength = edge.get("strength", 1) + + # 检查时间字段是否存在 + if "created_time" not in edge or "last_modified" not in edge: + need_update = True + # 更新数据库中的边 + update_data = {} + if "created_time" not in edge: + update_data["created_time"] = current_time + if "last_modified" not in edge: + update_data["last_modified"] = current_time + + db.graph_data.edges.update_one({"source": source, "target": target}, {"$set": update_data}) + logger.info(f"[时间更新] 边 {source} - {target} 添加缺失的时间字段") + + # 获取时间信息(如果不存在则使用当前时间) + created_time = edge.get("created_time", current_time) + last_modified = edge.get("last_modified", current_time) + + # 只有当源节点和目标节点都存在时才添加边 + if source in self.memory_graph.G and target in self.memory_graph.G: + self.memory_graph.G.add_edge( + source, target, strength=strength, created_time=created_time, last_modified=last_modified + ) + + if need_update: + logger.success("[数据库] 已为缺失的时间字段进行补充") + + async def resync_memory_to_db(self): + """清空数据库并重新同步所有记忆数据""" + start_time = time.time() + logger.info("[数据库] 开始重新同步所有记忆数据...") + + # 清空数据库 + clear_start = time.time() + db.graph_data.nodes.delete_many({}) + db.graph_data.edges.delete_many({}) + clear_end = time.time() + logger.info(f"[数据库] 清空数据库耗时: {clear_end - clear_start:.2f}秒") + + # 获取所有节点和边 + memory_nodes = list(self.memory_graph.G.nodes(data=True)) + memory_edges = list(self.memory_graph.G.edges(data=True)) + + # 重新写入节点 + node_start = time.time() + for concept, data in memory_nodes: + memory_items = data.get("memory_items", []) + if not isinstance(memory_items, list): + memory_items = [memory_items] if memory_items else [] + + node_data = { + "concept": concept, + "memory_items": memory_items, + "hash": self.hippocampus.calculate_node_hash(concept, memory_items), + "created_time": data.get("created_time", datetime.datetime.now().timestamp()), + "last_modified": data.get("last_modified", datetime.datetime.now().timestamp()), + } + db.graph_data.nodes.insert_one(node_data) + node_end = time.time() + logger.info(f"[数据库] 写入 {len(memory_nodes)} 个节点耗时: {node_end - node_start:.2f}秒") + + # 重新写入边 + edge_start = time.time() + for source, target, data in memory_edges: + edge_data = { + "source": source, + "target": target, + "strength": data.get("strength", 1), + "hash": self.hippocampus.calculate_edge_hash(source, target), + "created_time": data.get("created_time", datetime.datetime.now().timestamp()), + "last_modified": data.get("last_modified", datetime.datetime.now().timestamp()), + } + db.graph_data.edges.insert_one(edge_data) + edge_end = time.time() + logger.info(f"[数据库] 写入 {len(memory_edges)} 条边耗时: {edge_end - edge_start:.2f}秒") + + end_time = time.time() + logger.success(f"[数据库] 重新同步完成，总耗时: {end_time - start_time:.2f}秒") + logger.success(f"[数据库] 同步了 {len(memory_nodes)} 个节点和 {len(memory_edges)} 条边") + + # 负责整合，遗忘，合并记忆 class ParahippocampalGyrus: def __init__(self, hippocampus: Hippocampus): From 5d663347766c631e04d513d090cce4260d57e8e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 14:21:08 +0900 Subject: [PATCH 07/26] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=E6=9C=AA?= =?UTF-8?q?=E8=A7=A3=E6=9E=90=E7=9A=84=E9=A5=AE=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../memory_system/manually_alter_memory.py | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/plugins/memory_system/manually_alter_memory.py b/src/plugins/memory_system/manually_alter_memory.py index 81874211..1452d3d5 100644 --- a/src/plugins/memory_system/manually_alter_memory.py +++ b/src/plugins/memory_system/manually_alter_memory.py @@ -5,7 +5,8 @@ import time from pathlib import Path import datetime from rich.console import Console -from memory_manual_build import Memory_graph, Hippocampus # 海马体和记忆图 +from Hippocampus import Hippocampus # 海马体和记忆图 + from dotenv import load_dotenv @@ -45,13 +46,13 @@ else: # 查询节点信息 -def query_mem_info(memory_graph: Memory_graph): +def query_mem_info(hippocampus: Hippocampus): while True: query = input("\n请输入新的查询概念（输入'退出'以结束）：") if query.lower() == "退出": break - items_list = memory_graph.get_related_item(query) + items_list = hippocampus.memory_graph.get_related_item(query) if items_list: have_memory = False first_layer, second_layer = items_list @@ -312,14 +313,11 @@ def alter_mem_edge(hippocampus: Hippocampus): async def main(): start_time = time.time() - # 创建记忆图 - memory_graph = Memory_graph() - # 创建海马体 - hippocampus = Hippocampus(memory_graph) + hippocampus = Hippocampus() # 从数据库同步数据 - hippocampus.sync_memory_from_db() + hippocampus.entorhinal_cortex.sync_memory_from_db() end_time = time.time() logger.info(f"\033[32m[加载海马体耗时: {end_time - start_time:.2f} 秒]\033[0m") @@ -338,7 +336,7 @@ async def main(): query = -1 if query == 0: - query_mem_info(memory_graph) + query_mem_info(hippocampus.memory_graph) elif query == 1: add_mem_node(hippocampus) elif query == 2: @@ -355,7 +353,7 @@ async def main(): print("已结束操作") break - hippocampus.sync_memory_to_db() + hippocampus.entorhinal_cortex.sync_memory_to_db() if __name__ == "__main__": From 1dd3c62c553df60d52137f6942ff2e60a015314e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 14:32:32 +0900 Subject: [PATCH 08/26] chore: PEP8 naming --- src/main.py | 6 +++--- src/plugins/chat/bot.py | 4 ++-- .../heartFC_chat/heartFC_controler.py | 16 ++++++++-------- .../heartFC_chat/heartFC_processor.py | 14 +++++++------- .../chat_module/heartFC_chat/pf_chatting.py | 6 +++--- 5 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/main.py b/src/main.py index aad08b90..929cff7d 100644 --- a/src/main.py +++ b/src/main.py @@ -18,7 +18,7 @@ from .plugins.remote import heartbeat_thread # noqa: F401 from .individuality.individuality import Individuality from .common.server import global_server from .plugins.chat_module.heartFC_chat.interest import InterestManager -from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFC_Controller +from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFCController logger = get_module_logger("main") @@ -118,8 +118,8 @@ class MainSystem: logger.success("兴趣管理器后台任务启动成功") # 初始化并独立启动 HeartFC_Chat - HeartFC_Controller() - heartfc_chat_instance = HeartFC_Controller.get_instance() + HeartFCController() + heartfc_chat_instance = HeartFCController.get_instance() if heartfc_chat_instance: await heartfc_chat_instance.start() logger.success("HeartFC_Chat 模块独立启动成功") diff --git a/src/plugins/chat/bot.py b/src/plugins/chat/bot.py index 314d20ff..cfe4238e 100644 --- a/src/plugins/chat/bot.py +++ b/src/plugins/chat/bot.py @@ -7,7 +7,7 @@ from ..chat_module.only_process.only_message_process import MessageProcessor from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig from ..chat_module.reasoning_chat.reasoning_chat import ReasoningChat -from ..chat_module.heartFC_chat.heartFC_processor import HeartFC_Processor +from ..chat_module.heartFC_chat.heartFC_processor import HeartFCProcessor from ..utils.prompt_builder import Prompt, global_prompt_manager import traceback @@ -29,7 +29,7 @@ class ChatBot: self.mood_manager = MoodManager.get_instance() # 获取情绪管理器单例 self.mood_manager.start_mood_update() # 启动情绪更新 self.reasoning_chat = ReasoningChat() - self.heartFC_processor = HeartFC_Processor() # 新增 + self.heartFC_processor = HeartFCProcessor() # 新增 # 创建初始化PFC管理器的任务，会在_ensure_started时执行 self.only_process_chat = MessageProcessor() diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py index 389e030a..a217f978 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py @@ -20,18 +20,18 @@ chat_config = LogConfig( file_format=CHAT_STYLE_CONFIG["file_format"], ) -logger = get_module_logger("HeartFC_Controller", config=chat_config) +logger = get_module_logger("HeartFCController", config=chat_config) # 检测群聊兴趣的间隔时间 INTEREST_MONITOR_INTERVAL_SECONDS = 1 -class HeartFC_Controller: +class HeartFCController: _instance = None # For potential singleton access if needed by MessageManager def __init__(self): # --- Updated Init --- - if HeartFC_Controller._instance is not None: + if HeartFCController._instance is not None: # Prevent re-initialization if used as a singleton return self.gpt = ResponseGenerator() @@ -44,7 +44,7 @@ class HeartFC_Controller: self.pf_chatting_instances: Dict[str, PFChatting] = {} self._pf_chatting_lock = Lock() # --- End New PFChatting Management --- - HeartFC_Controller._instance = self # Register instance + HeartFCController._instance = self # Register instance # --- End Updated Init --- # --- Make dependencies accessible for PFChatting --- # These are accessed via the passed instance in PFChatting @@ -58,7 +58,7 @@ class HeartFC_Controller: def get_instance(cls): if cls._instance is None: # This might indicate an issue if called before initialization - logger.warning("HeartFC_Controller get_instance called before initialization.") + logger.warning("HeartFCController get_instance called before initialization.") # Optionally, initialize here if a strict singleton pattern is desired # cls._instance = cls() return cls._instance @@ -67,9 +67,9 @@ class HeartFC_Controller: async def start(self): """启动异步任务,如回复启动器""" - logger.debug("HeartFC_Controller 正在启动异步任务...") + logger.debug("HeartFCController 正在启动异步任务...") self._initialize_monitor_task() - logger.info("HeartFC_Controller 异步任务启动完成") + logger.info("HeartFCController 异步任务启动完成") def _initialize_monitor_task(self): """启动后台兴趣监控任务，可以检查兴趣是否足以开启心流对话""" @@ -89,7 +89,7 @@ class HeartFC_Controller: async with self._pf_chatting_lock: if stream_id not in self.pf_chatting_instances: logger.info(f"为流 {stream_id} 创建新的PFChatting实例") - # 传递 self (HeartFC_Controller 实例) 进行依赖注入 + # 传递 self (HeartFCController 实例) 进行依赖注入 instance = PFChatting(stream_id, self) # 执行异步初始化 if not await instance._initialize(): diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py index 37708a94..44849f82 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py @@ -25,7 +25,7 @@ logger = get_module_logger("heartFC_processor", config=processor_config) # INTEREST_INCREASE_THRESHOLD = 0.5 -class HeartFC_Processor: +class HeartFCProcessor: def __init__(self): self.storage = MessageStorage() self.interest_manager = InterestManager() @@ -97,21 +97,21 @@ class HeartFC_Processor: # 处理缓冲器结果 (Bombing logic) if not buffer_result: - F_type = "seglist" + f_type = "seglist" if message.message_segment.type != "seglist": - F_type = message.message_segment.type + f_type = message.message_segment.type else: if ( isinstance(message.message_segment.data, list) and all(isinstance(x, Seg) for x in message.message_segment.data) and len(message.message_segment.data) == 1 ): - F_type = message.message_segment.data[0].type - if F_type == "text": + f_type = message.message_segment.data[0].type + if f_type == "text": logger.debug(f"触发缓冲，消息：{message.processed_plain_text}") - elif F_type == "image": + elif f_type == "image": logger.debug("触发缓冲，表情包/图片等待中") - elif F_type == "seglist": + elif f_type == "seglist": logger.debug("触发缓冲，消息列表等待中") return # 被缓冲器拦截，不生成回复 diff --git a/src/plugins/chat_module/heartFC_chat/pf_chatting.py b/src/plugins/chat_module/heartFC_chat/pf_chatting.py index 59472fd1..620a9eea 100644 --- a/src/plugins/chat_module/heartFC_chat/pf_chatting.py +++ b/src/plugins/chat_module/heartFC_chat/pf_chatting.py @@ -25,7 +25,7 @@ logger = get_module_logger("PFCLoop", config=interest_log_config) # Logger Name # Forward declaration for type hinting if TYPE_CHECKING: - from .heartFC_controler import HeartFC_Controller + from .heartFC_controler import HeartFCController PLANNER_TOOL_DEFINITION = [ { @@ -61,7 +61,7 @@ class PFChatting: 只要计时器>0，循环就会继续。 """ - def __init__(self, chat_id: str, heartfc_controller_instance: "HeartFC_Controller"): + def __init__(self, chat_id: str, heartfc_controller_instance: "HeartFCController"): """ 初始化PFChatting实例。 @@ -771,7 +771,7 @@ class PFChatting: logger.error(traceback.format_exc()) return None - # --- Methods moved from HeartFC_Controller start --- + # --- Methods moved from HeartFCController start --- async def _create_thinking_message(self, anchor_message: Optional[MessageRecv]) -> Optional[str]: """创建思考消息 (尝试锚定到 anchor_message)""" if not anchor_message or not anchor_message.chat_stream: From 13e05adf806806f90edac86f8dbe294f89113991 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 14:42:33 +0900 Subject: [PATCH 09/26] =?UTF-8?q?chore:=20=E6=98=BE=E5=BC=8F=E8=BF=94?= =?UTF-8?q?=E5=9B=9ENone?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/individuality/individuality.py | 1 + src/plugins/PFC/conversation.py | 8 +++++ src/plugins/chat/message.py | 12 ++++---- src/plugins/chat/utils.py | 5 ++-- .../reasoning_chat/reasoning_chat.py | 29 ++++++++++--------- src/plugins/message/message_base.py | 1 - src/plugins/person_info/person_info.py | 2 +- src/plugins/remote/remote.py | 1 + 8 files changed, 35 insertions(+), 24 deletions(-) diff --git a/src/individuality/individuality.py b/src/individuality/individuality.py index e7616ec2..2a489338 100644 --- a/src/individuality/individuality.py +++ b/src/individuality/individuality.py @@ -105,3 +105,4 @@ class Individuality: return self.personality.agreeableness elif factor == "neuroticism": return self.personality.neuroticism + return None diff --git a/src/plugins/PFC/conversation.py b/src/plugins/PFC/conversation.py index 598468e8..9502b755 100644 --- a/src/plugins/PFC/conversation.py +++ b/src/plugins/PFC/conversation.py @@ -180,6 +180,7 @@ class Conversation: "time": datetime.datetime.now().strftime("%H:%M:%S"), } ) + return None elif action == "fetch_knowledge": self.waiter.wait_accumulated_time = 0 @@ -193,28 +194,35 @@ class Conversation: if knowledge: if topic not in self.conversation_info.knowledge_list: self.conversation_info.knowledge_list.append({"topic": topic, "knowledge": knowledge}) + return None else: self.conversation_info.knowledge_list[topic] += knowledge + return None + return None elif action == "rethink_goal": self.waiter.wait_accumulated_time = 0 self.state = ConversationState.RETHINKING await self.goal_analyzer.analyze_goal(conversation_info, observation_info) + return None elif action == "listening": self.state = ConversationState.LISTENING logger.info("倾听对方发言...") await self.waiter.wait_listening(conversation_info) + return None elif action == "end_conversation": self.should_continue = False logger.info("决定结束对话...") + return None else: # wait self.state = ConversationState.WAITING logger.info("等待更多信息...") await self.waiter.wait(self.conversation_info) + return None async def _send_timeout_message(self): """发送超时结束消息""" diff --git a/src/plugins/chat/message.py b/src/plugins/chat/message.py index cbea1fd9..87380e7c 100644 --- a/src/plugins/chat/message.py +++ b/src/plugins/chat/message.py @@ -1,14 +1,13 @@ import time from dataclasses import dataclass -from typing import Dict, List, Optional +from typing import Dict, List, Optional, Union import urllib3 -from .utils_image import image_manager - -from ..message.message_base import Seg, UserInfo, BaseMessageInfo, MessageBase -from .chat_stream import ChatStream from src.common.logger import get_module_logger +from .chat_stream import ChatStream +from .utils_image import image_manager +from ..message.message_base import Seg, UserInfo, BaseMessageInfo, MessageBase logger = get_module_logger("chat_message") @@ -207,7 +206,7 @@ class MessageProcessBase(Message): # 处理单个消息段 return await self._process_single_segment(segment) - async def _process_single_segment(self, seg: Seg) -> str: + async def _process_single_segment(self, seg: Seg) -> Union[str, None]: """处理单个消息段 Args: @@ -233,6 +232,7 @@ class MessageProcessBase(Message): elif seg.type == "reply": if self.reply and hasattr(self.reply, "processed_plain_text"): return f"[回复：{self.reply.processed_plain_text}]" + return None else: return f"[{seg.type}:{str(seg.data)}]" except Exception as e: diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index 9c98a16a..3e4cfa52 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -2,7 +2,7 @@ import random import time import re from collections import Counter -from typing import Dict, List +from typing import Dict, List, Optional import jieba import numpy as np @@ -688,7 +688,7 @@ def count_messages_between(start_time: float, end_time: float, stream_id: str) - return 0, 0 -def translate_timestamp_to_human_readable(timestamp: float, mode: str = "normal") -> str: +def translate_timestamp_to_human_readable(timestamp: float, mode: str = "normal") -> Optional[str]: """将时间戳转换为人类可读的时间格式 Args: @@ -716,6 +716,7 @@ def translate_timestamp_to_human_readable(timestamp: float, mode: str = "normal" return f"{int(diff / 86400)}天前:\n" else: return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp)) + ":\n" + return None def parse_text_timestamps(text: str, mode: str = "normal") -> str: diff --git a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py index d149f68b..2eb56c83 100644 --- a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py +++ b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py @@ -1,25 +1,26 @@ import time -from random import random import traceback -from typing import List -from ...memory_system.Hippocampus import HippocampusManager -from ...moods.moods import MoodManager -from ....config.config import global_config -from ...chat.emoji_manager import emoji_manager +from random import random +from typing import List, Optional + +from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig +from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager from .reasoning_generator import ResponseGenerator +from ...chat.chat_stream import chat_manager +from ...chat.emoji_manager import emoji_manager from ...chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet +from ...chat.message_buffer import message_buffer from ...chat.messagesender import message_manager -from ...storage.storage import MessageStorage from ...chat.utils import is_mentioned_bot_in_message from ...chat.utils_image import image_path_to_base64 -from ...willing.willing_manager import willing_manager +from ...memory_system.Hippocampus import HippocampusManager from ...message import UserInfo, Seg -from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig -from ...chat.chat_stream import chat_manager +from ...moods.moods import MoodManager from ...person_info.relationship_manager import relationship_manager -from ...chat.message_buffer import message_buffer -from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager +from ...storage.storage import MessageStorage from ...utils.timer_calculater import Timer +from ...willing.willing_manager import willing_manager +from ....config.config import global_config # 定义日志配置 chat_config = LogConfig( @@ -61,7 +62,7 @@ class ReasoningChat: return thinking_id @staticmethod - async def _send_response_messages(message, chat, response_set: List[str], thinking_id) -> MessageSending: + async def _send_response_messages(message, chat, response_set: List[str], thinking_id) -> Optional[MessageSending]: """发送回复消息""" container = message_manager.get_container(chat.stream_id) thinking_message = None @@ -74,7 +75,7 @@ class ReasoningChat: if not thinking_message: logger.warning("未找到对应的思考消息，可能已超时被移除") - return + return None thinking_start_time = thinking_message.thinking_start_time message_set = MessageSet(chat, thinking_id) diff --git a/src/plugins/message/message_base.py b/src/plugins/message/message_base.py index 2f177670..b853d469 100644 --- a/src/plugins/message/message_base.py +++ b/src/plugins/message/message_base.py @@ -12,7 +12,6 @@ class Seg: - 对于 text 类型，data 是字符串 - 对于 image 类型，data 是 base64 字符串 - 对于 seglist 类型，data 是 Seg 列表 - translated_data: 经过翻译处理的数据（可选） """ type: str diff --git a/src/plugins/person_info/person_info.py b/src/plugins/person_info/person_info.py index 8105b330..b4404988 100644 --- a/src/plugins/person_info/person_info.py +++ b/src/plugins/person_info/person_info.py @@ -169,7 +169,7 @@ class PersonInfoManager: """给某个用户取名""" if not person_id: logger.debug("取名失败：person_id不能为空") - return + return None old_name = await self.get_value(person_id, "person_name") old_reason = await self.get_value(person_id, "name_reason") diff --git a/src/plugins/remote/remote.py b/src/plugins/remote/remote.py index 0d119a3e..5bc4dab1 100644 --- a/src/plugins/remote/remote.py +++ b/src/plugins/remote/remote.py @@ -134,3 +134,4 @@ def main(): heartbeat_thread.start() return heartbeat_thread # 返回线程对象，便于外部控制 + return None From 1e481a7af1d3ca85a532efd8517d4b4c486a694d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 14:49:14 +0900 Subject: [PATCH 10/26] fix: unreachable? --- .../chat_module/heartFC_chat/pf_chatting.py | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/src/plugins/chat_module/heartFC_chat/pf_chatting.py b/src/plugins/chat_module/heartFC_chat/pf_chatting.py index 620a9eea..2bb89987 100644 --- a/src/plugins/chat_module/heartFC_chat/pf_chatting.py +++ b/src/plugins/chat_module/heartFC_chat/pf_chatting.py @@ -374,6 +374,22 @@ class PFChatting: ) action_taken_this_cycle = False + # --- Print Timer Results --- # + if cycle_timers: # 先检查cycle_timers是否非空 + timer_strings = [] + for name, elapsed in cycle_timers.items(): + # 直接格式化存储在字典中的浮点数 elapsed + formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒" + timer_strings.append(f"{name}: {formatted_time}") + + if timer_strings: # 如果有有效计时器数据才打印 + logger.debug( + f"{log_prefix} test testtesttesttesttesttesttesttesttesttest Cycle Timers: {'; '.join(timer_strings)}" + ) + + # --- Timer Decrement --- # + cycle_duration = time.monotonic() - loop_cycle_start_time + except Exception as e_cycle: logger.error(f"{log_prefix} 循环周期执行时发生错误: {e_cycle}") logger.error(traceback.format_exc()) @@ -387,21 +403,6 @@ class PFChatting: self._processing_lock.release() logger.trace(f"{log_prefix} 循环释放了处理锁.") - # --- Print Timer Results --- # - if cycle_timers: # 先检查cycle_timers是否非空 - timer_strings = [] - for name, elapsed in cycle_timers.items(): - # 直接格式化存储在字典中的浮点数 elapsed - formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒" - timer_strings.append(f"{name}: {formatted_time}") - - if timer_strings: # 如果有有效计时器数据才打印 - logger.debug( - f"{log_prefix} test testtesttesttesttesttesttesttesttesttest Cycle Timers: {'; '.join(timer_strings)}" - ) - - # --- Timer Decrement --- # - cycle_duration = time.monotonic() - loop_cycle_start_time async with self._timer_lock: self._loop_timer -= cycle_duration # Log timer decrement less aggressively From 6cb317123d8e403e6f6a81b3b080042c492d2645 Mon Sep 17 00:00:00 2001 From: UnCLAS-Prommer Date: Mon, 21 Apr 2025 14:50:25 +0800 Subject: [PATCH 11/26] =?UTF-8?q?ai=E8=AF=B4=E7=9A=84=E5=A5=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/api/__init__.py | 7 ++ src/api/config_api.py | 153 ++++++++++++++++++++++++++++++ src/plugins/models/utils_model.py | 18 +++- 3 files changed, 173 insertions(+), 5 deletions(-) create mode 100644 src/api/__init__.py create mode 100644 src/api/config_api.py diff --git a/src/api/__init__.py b/src/api/__init__.py new file mode 100644 index 00000000..11c09148 --- /dev/null +++ b/src/api/__init__.py @@ -0,0 +1,7 @@ +from fastapi import FastAPI +from strawberry.fastapi import GraphQLRouter +app = FastAPI() + +graphql_router = GraphQLRouter(schema=None, path="/") # Replace `None` with your actual schema + +app.include_router(graphql_router, prefix="/graphql", tags=["GraphQL"]) \ No newline at end of file diff --git a/src/api/config_api.py b/src/api/config_api.py new file mode 100644 index 00000000..3f323ff8 --- /dev/null +++ b/src/api/config_api.py @@ -0,0 +1,153 @@ +from typing import Dict, List, Optional +import strawberry +from packaging.version import Version, InvalidVersion +from packaging.specifiers import SpecifierSet, InvalidSpecifier +from ..config.config import global_config +import os + + +@strawberry.type +class BotConfig: + """机器人配置类""" + + INNER_VERSION: Version + MAI_VERSION: str # 硬编码的版本信息 + + # bot + BOT_QQ: Optional[int] + BOT_NICKNAME: Optional[str] + BOT_ALIAS_NAMES: List[str] # 别名，可以通过这个叫它 + + # group + talk_allowed_groups: set + talk_frequency_down_groups: set + ban_user_id: set + + # personality + personality_core: str # 建议20字以内，谁再写3000字小作文敲谁脑袋 + personality_sides: List[str] + # identity + identity_detail: List[str] + height: int # 身高 单位厘米 + weight: int # 体重 单位千克 + age: int # 年龄 单位岁 + gender: str # 性别 + appearance: str # 外貌特征 + + # schedule + ENABLE_SCHEDULE_GEN: bool # 是否启用日程生成 + PROMPT_SCHEDULE_GEN: str + SCHEDULE_DOING_UPDATE_INTERVAL: int # 日程表更新间隔 单位秒 + SCHEDULE_TEMPERATURE: float # 日程表温度，建议0.5-1.0 + TIME_ZONE: str # 时区 + + # message + MAX_CONTEXT_SIZE: int # 上下文最大消息数 + emoji_chance: float # 发送表情包的基础概率 + thinking_timeout: int # 思考时间 + max_response_length: int # 最大回复长度 + message_buffer: bool # 消息缓冲器 + + ban_words: set + ban_msgs_regex: set + # heartflow + # enable_heartflow: bool = False # 是否启用心流 + sub_heart_flow_update_interval: int # 子心流更新频率，间隔 单位秒 + sub_heart_flow_freeze_time: int # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒 + sub_heart_flow_stop_time: int # 子心流停止时间，超过这个时间没有回复，子心流会停止，间隔 单位秒 + heart_flow_update_interval: int # 心流更新频率，间隔 单位秒 + observation_context_size: int # 心流观察到的最长上下文大小，超过这个值的上下文会被压缩 + compressed_length: int # 不能大于observation_context_size,心流上下文压缩的最短压缩长度，超过心流观察到的上下文长度，会压缩，最短压缩长度为5 + compress_length_limit: int # 最多压缩份数，超过该数值的压缩上下文会被删除 + + # willing + willing_mode: str # 意愿模式 + response_willing_amplifier: float # 回复意愿放大系数 + response_interested_rate_amplifier: float # 回复兴趣度放大系数 + down_frequency_rate: float # 降低回复频率的群组回复意愿降低系数 + emoji_response_penalty: float # 表情包回复惩罚 + mentioned_bot_inevitable_reply: bool # 提及 bot 必然回复 + at_bot_inevitable_reply: bool # @bot 必然回复 + + # response + response_mode: str # 回复策略 + MODEL_R1_PROBABILITY: float # R1模型概率 + MODEL_V3_PROBABILITY: float # V3模型概率 + # MODEL_R1_DISTILL_PROBABILITY: float # R1蒸馏模型概率 + + # emoji + max_emoji_num: int # 表情包最大数量 + max_reach_deletion: bool # 开启则在达到最大数量时删除表情包，关闭则不会继续收集表情包 + EMOJI_CHECK_INTERVAL: int # 表情包检查间隔（分钟） + EMOJI_REGISTER_INTERVAL: int # 表情包注册间隔（分钟） + EMOJI_SAVE: bool # 偷表情包 + EMOJI_CHECK: bool # 是否开启过滤 + EMOJI_CHECK_PROMPT: str # 表情包过滤要求 + + # memory + build_memory_interval: int # 记忆构建间隔（秒） + memory_build_distribution: list # 记忆构建分布，参数：分布1均值，标准差，权重，分布2均值，标准差，权重 + build_memory_sample_num: int # 记忆构建采样数量 + build_memory_sample_length: int # 记忆构建采样长度 + memory_compress_rate: float # 记忆压缩率 + + forget_memory_interval: int # 记忆遗忘间隔（秒） + memory_forget_time: int # 记忆遗忘时间（小时） + memory_forget_percentage: float # 记忆遗忘比例 + + memory_ban_words: list # 添加新的配置项默认值 + + # mood + mood_update_interval: float # 情绪更新间隔 单位秒 + mood_decay_rate: float # 情绪衰减率 + mood_intensity_factor: float # 情绪强度因子 + + # keywords + keywords_reaction_rules: list # 关键词回复规则 + + # chinese_typo + chinese_typo_enable: bool # 是否启用中文错别字生成器 + chinese_typo_error_rate: float # 单字替换概率 + chinese_typo_min_freq: int # 最小字频阈值 + chinese_typo_tone_error_rate: float # 声调错误概率 + chinese_typo_word_replace_rate: float # 整词替换概率 + + # response_splitter + enable_response_splitter: bool # 是否启用回复分割器 + response_max_length: int # 回复允许的最大长度 + response_max_sentence_num: int # 回复允许的最大句子数 + + # remote + remote_enable: bool # 是否启用远程控制 + + # experimental + enable_friend_chat: bool # 是否启用好友聊天 + # enable_think_flow: bool # 是否启用思考流程 + enable_pfc_chatting: bool # 是否启用PFC聊天 + + # 模型配置 + llm_reasoning: Dict[str, str] # LLM推理 + # llm_reasoning_minor: Dict[str, str] + llm_normal: Dict[str, str] # LLM普通 + llm_topic_judge: Dict[str, str] # LLM话题判断 + llm_summary_by_topic: Dict[str, str] # LLM话题总结 + llm_emotion_judge: Dict[str, str] # LLM情感判断 + embedding: Dict[str, str] # 嵌入 + vlm: Dict[str, str] # VLM + moderation: Dict[str, str] # 审核 + + # 实验性 + llm_observation: Dict[str, str] # LLM观察 + llm_sub_heartflow: Dict[str, str] # LLM子心流 + llm_heartflow: Dict[str, str] # LLM心流 + + api_urls: Dict[str, str] # API URLs + + +@strawberry.type +class EnvConfig: + pass + + @strawberry.field + def get_env(self) -> str: + return "env" diff --git a/src/plugins/models/utils_model.py b/src/plugins/models/utils_model.py index 1faebc3e..5fd11692 100644 --- a/src/plugins/models/utils_model.py +++ b/src/plugins/models/utils_model.py @@ -68,13 +68,20 @@ error_code_mapping = { class LLMRequest: # 定义需要转换的模型列表，作为类变量避免重复 MODELS_NEEDING_TRANSFORMATION = [ - "o3-mini", - "o1-mini", - "o1-preview", + "o1", "o1-2024-12-17", - "o1-preview-2024-09-12", - "o3-mini-2025-01-31", + "o1-mini", "o1-mini-2024-09-12", + "o1-preview", + "o1-preview-2024-09-12", + "o1-pro", + "o1-pro-2025-03-19", + "o3", + "o3-2025-04-16", + "o3-mini", + "o3-mini-2025-01-31" + "o4-mini", + "o4-mini-2025-04-16", ] def __init__(self, model: dict, **kwargs): @@ -800,6 +807,7 @@ class LLMRequest: policy = request_content["policy"] payload = request_content["payload"] keep_request = False + wait_time = 0.1 if retry_count < policy["max_retries"] - 1: wait_time = policy["base_wait"] * (2**retry_count) keep_request = True From cbfa8508c6a32fcfd4bec1a19284d6a108456090 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=98=A5=E6=B2=B3=E6=99=B4?= Date: Mon, 21 Apr 2025 15:56:17 +0900 Subject: [PATCH 12/26] chore: update README and template.env for better formatting and clarity --- README.md | 7 +++---- template/template.env | 20 +++++++++++++++----- 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 656f536a..26cd30f6 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@

- Logo + Logo
@@ -34,7 +34,6 @@ · 提出新特性

-

## 新版0.6.x部署前先阅读：https://docs.mai-mai.org/manual/usage/mmc_q_a @@ -53,7 +52,7 @@
- 麦麦演示视频 + 麦麦演示视频
👆 点击观看麦麦演示视频 👆 @@ -186,7 +185,7 @@ MaiCore是一个开源项目，我们非常欢迎你的参与。你的贡献， 感谢各位大佬！ - + contributors **也感谢每一位给麦麦发展提出宝贵意见与建议的用户，感谢陪伴麦麦走到现在的你们** diff --git a/template/template.env b/template/template.env index 06e9b07e..c1a6dd0d 100644 --- a/template/template.env +++ b/template/template.env @@ -29,8 +29,18 @@ CHAT_ANY_WHERE_KEY= SILICONFLOW_KEY= # 定义日志相关配置 -SIMPLE_OUTPUT=true # 精简控制台输出格式 -CONSOLE_LOG_LEVEL=INFO # 自定义日志的默认控制台输出日志级别 -FILE_LOG_LEVEL=DEBUG # 自定义日志的默认文件输出日志级别 -DEFAULT_CONSOLE_LOG_LEVEL=SUCCESS # 原生日志的控制台输出日志级别（nonebot就是这一类） -DEFAULT_FILE_LOG_LEVEL=DEBUG # 原生日志的默认文件输出日志级别（nonebot就是这一类） \ No newline at end of file + +# 精简控制台输出格式 +SIMPLE_OUTPUT=true + +# 自定义日志的默认控制台输出日志级别 +CONSOLE_LOG_LEVEL=INFO + +# 自定义日志的默认文件输出日志级别 +FILE_LOG_LEVEL=DEBUG + +# 原生日志的控制台输出日志级别（nonebot就是这一类） +DEFAULT_CONSOLE_LOG_LEVEL=SUCCESS + +# 原生日志的默认文件输出日志级别（nonebot就是这一类） +DEFAULT_FILE_LOG_LEVEL=DEBUG From 7d2f5b51a7f6af71c44ff2333f759e671ce1479b Mon Sep 17 00:00:00 2001 From: UnCLAS-Prommer Date: Mon, 21 Apr 2025 15:25:29 +0800 Subject: [PATCH 13/26] =?UTF-8?q?=E5=90=88=E5=B9=B6openai=E5=85=BC?= =?UTF-8?q?=E5=AE=B9=EF=BC=8C=E8=BF=87ruff?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/api/config_api.py | 10 +++--- src/plugins/models/utils_model.py | 53 ++++++++++++++----------------- 2 files changed, 28 insertions(+), 35 deletions(-) diff --git a/src/api/config_api.py b/src/api/config_api.py index 3f323ff8..650cbf63 100644 --- a/src/api/config_api.py +++ b/src/api/config_api.py @@ -1,10 +1,10 @@ from typing import Dict, List, Optional import strawberry -from packaging.version import Version, InvalidVersion -from packaging.specifiers import SpecifierSet, InvalidSpecifier -from ..config.config import global_config -import os - +# from packaging.version import Version, InvalidVersion +# from packaging.specifiers import SpecifierSet, InvalidSpecifier +# from ..config.config import global_config +# import os +from packaging.version import Version @strawberry.type class BotConfig: diff --git a/src/plugins/models/utils_model.py b/src/plugins/models/utils_model.py index 5fd11692..365b15a6 100644 --- a/src/plugins/models/utils_model.py +++ b/src/plugins/models/utils_model.py @@ -79,8 +79,7 @@ class LLMRequest: "o3", "o3-2025-04-16", "o3-mini", - "o3-mini-2025-01-31" - "o4-mini", + "o3-mini-2025-01-31o4-mini", "o4-mini-2025-04-16", ] @@ -806,10 +805,8 @@ class LLMRequest: ) -> Union[Tuple[Dict[str, Any], int], Tuple[None, int]]: policy = request_content["policy"] payload = request_content["payload"] - keep_request = False - wait_time = 0.1 + wait_time = policy["base_wait"] * (2**retry_count) if retry_count < policy["max_retries"] - 1: - wait_time = policy["base_wait"] * (2**retry_count) keep_request = True if isinstance(exception, RequestAbortException): response = exception.response @@ -989,30 +986,27 @@ class LLMRequest: # 复制一份参数，避免直接修改 self.params params_copy = await self._transform_parameters(self.params) if image_base64: - payload = { - "model": self.model_name, - "messages": [ - { - "role": "user", - "content": [ - {"type": "text", "text": prompt}, - { - "type": "image_url", - "image_url": {"url": f"data:image/{image_format.lower()};base64,{image_base64}"}, - }, - ], - } - ], - "max_tokens": global_config.max_response_length, - **params_copy, - } + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": prompt}, + { + "type": "image_url", + "image_url": {"url": f"data:image/{image_format.lower()};base64,{image_base64}"}, + }, + ], + } + ] else: - payload = { - "model": self.model_name, - "messages": [{"role": "user", "content": prompt}], - "max_tokens": global_config.max_response_length, - **params_copy, - } + messages = [{"role": "user", "content": prompt}] + payload = { + "model": self.model_name, + "messages": messages, + **params_copy, + } + if "max_tokens" not in payload and "max_completion_tokens" not in payload: + payload["max_tokens"] = global_config.max_response_length # 如果 payload 中依然存在 max_tokens 且需要转换，在这里进行再次检查 if self.model_name.lower() in self.MODELS_NEEDING_TRANSFORMATION and "max_tokens" in payload: payload["max_completion_tokens"] = payload.pop("max_tokens") @@ -1105,11 +1099,10 @@ class LLMRequest: async def generate_response_async(self, prompt: str, **kwargs) -> Union[str, Tuple]: """异步方式根据输入的提示生成模型的响应""" - # 构建请求体 + # 构建请求体，不硬编码max_tokens data = { "model": self.model_name, "messages": [{"role": "user", "content": prompt}], - "max_tokens": global_config.max_response_length, **self.params, **kwargs, } From 6e0a3cf8cf183429c3cdb9aca45c7213604d5bef Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 21 Apr 2025 07:26:08 +0000 Subject: [PATCH 14/26] =?UTF-8?q?=F0=9F=A4=96=20=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=20[skip=20ci]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/api/__init__.py | 3 ++- src/api/config_api.py | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/api/__init__.py b/src/api/__init__.py index 11c09148..f5bc08a6 100644 --- a/src/api/__init__.py +++ b/src/api/__init__.py @@ -1,7 +1,8 @@ from fastapi import FastAPI from strawberry.fastapi import GraphQLRouter + app = FastAPI() graphql_router = GraphQLRouter(schema=None, path="/") # Replace `None` with your actual schema -app.include_router(graphql_router, prefix="/graphql", tags=["GraphQL"]) \ No newline at end of file +app.include_router(graphql_router, prefix="/graphql", tags=["GraphQL"]) diff --git a/src/api/config_api.py b/src/api/config_api.py index 650cbf63..e3934617 100644 --- a/src/api/config_api.py +++ b/src/api/config_api.py @@ -1,11 +1,13 @@ from typing import Dict, List, Optional import strawberry + # from packaging.version import Version, InvalidVersion # from packaging.specifiers import SpecifierSet, InvalidSpecifier # from ..config.config import global_config # import os from packaging.version import Version + @strawberry.type class BotConfig: """机器人配置类""" From c10b7eea61b9f352475363f4c92883cd6f4e055b Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 18:37:49 +0800 Subject: [PATCH 15/26] =?UTF-8?q?feat:=20=E6=95=B4=E5=90=88reasoning?= =?UTF-8?q?=E6=A8=A1=E5=BC=8F=E5=92=8Chfc=E6=A8=A1=E5=BC=8F=EF=BC=8C?= =?UTF-8?q?=E7=BB=9F=E4=B8=80=E8=B0=83=E6=8E=A7=EF=BC=88=E4=BD=86=E4=B8=8D?= =?UTF-8?q?=E6=98=AF=E5=BE=88=E7=BB=9F=E4=B8=80=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/config/config.py | 28 +- src/heart_flow/heartflow.py | 10 +- src/heart_flow/sub_heartflow.py | 11 +- src/main.py | 8 +- src/plugins/chat/bot.py | 2 - .../heartFC_chat/heartFC_controler.py | 82 ++-- .../heartFC_chat/heartFC_processor.py | 16 +- .../chat_module/heartFC_chat/interest.py | 12 + .../heartFC_chat/reasoning_chat.py | 412 ++++++++++++++++ .../heartFC_chat/reasoning_generator.py | 199 ++++++++ .../heartFC_chat/reasoning_prompt_builder.py | 445 ++++++++++++++++++ .../reasoning_chat/reasoning_chat.py | 43 +- .../reasoning_chat/reasoning_generator.py | 2 +- src/plugins/memory_system/Hippocampus.py | 6 +- 14 files changed, 1188 insertions(+), 88 deletions(-) create mode 100644 src/plugins/chat_module/heartFC_chat/reasoning_chat.py create mode 100644 src/plugins/chat_module/heartFC_chat/reasoning_generator.py create mode 100644 src/plugins/chat_module/heartFC_chat/reasoning_prompt_builder.py diff --git a/src/config/config.py b/src/config/config.py index d2fe6f0f..83e47837 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -213,8 +213,8 @@ class BotConfig: # response response_mode: str = "heart_flow" # 回复策略 - model_reasoning_probability: float = 0.7 # 麦麦回答时选择推理模型(主要)模型概率 - model_normal_probability: float = 0.3 # 麦麦回答时选择一般模型(次要)模型概率 + model_reasoning_probability: float = 0.7 # 麦麦回答时选择推理模型(主要)模型概率 + model_normal_probability: float = 0.3 # 麦麦回答时选择一般模型(次要)模型概率 # MODEL_R1_DISTILL_PROBABILITY: float = 0.1 # R1蒸馏模型概率 # emoji @@ -407,10 +407,13 @@ class BotConfig: def response(parent: dict): response_config = parent["response"] - config.model_reasoning_probability = response_config.get("model_reasoning_probability", config.model_reasoning_probability) - config.model_normal_probability = response_config.get("model_normal_probability", config.model_normal_probability) - - + config.model_reasoning_probability = response_config.get( + "model_reasoning_probability", config.model_reasoning_probability + ) + config.model_normal_probability = response_config.get( + "model_normal_probability", config.model_normal_probability + ) + # 添加 enable_heart_flowC 的加载逻辑 (假设它在 [response] 部分) if config.INNER_VERSION in SpecifierSet(">=1.4.0"): config.enable_heart_flowC = response_config.get("enable_heart_flowC", config.enable_heart_flowC) @@ -418,7 +421,6 @@ class BotConfig: def heartflow(parent: dict): heartflow_config = parent["heartflow"] # 加载新增的 heartflowC 参数 - # 加载原有的 heartflow 参数 # config.sub_heart_flow_update_interval = heartflow_config.get( @@ -442,9 +444,15 @@ class BotConfig: "compress_length_limit", config.compress_length_limit ) if config.INNER_VERSION in SpecifierSet(">=1.4.0"): - config.reply_trigger_threshold = heartflow_config.get("reply_trigger_threshold", config.reply_trigger_threshold) - config.probability_decay_factor_per_second = heartflow_config.get("probability_decay_factor_per_second", config.probability_decay_factor_per_second) - config.default_decay_rate_per_second = heartflow_config.get("default_decay_rate_per_second", config.default_decay_rate_per_second) + config.reply_trigger_threshold = heartflow_config.get( + "reply_trigger_threshold", config.reply_trigger_threshold + ) + config.probability_decay_factor_per_second = heartflow_config.get( + "probability_decay_factor_per_second", config.probability_decay_factor_per_second + ) + config.default_decay_rate_per_second = heartflow_config.get( + "default_decay_rate_per_second", config.default_decay_rate_per_second + ) config.initial_duration = heartflow_config.get("initial_duration", config.initial_duration) def willing(parent: dict): diff --git a/src/heart_flow/heartflow.py b/src/heart_flow/heartflow.py index c2f922ff..50f0a735 100644 --- a/src/heart_flow/heartflow.py +++ b/src/heart_flow/heartflow.py @@ -45,6 +45,8 @@ class CurrentState: def __init__(self): self.current_state_info = "" + self.chat_status = "IDLE" + self.mood_manager = MoodManager() self.mood = self.mood_manager.get_prompt() @@ -70,7 +72,7 @@ class Heartflow: """定期清理不活跃的子心流""" while True: current_time = time.time() - inactive_subheartflows_ids = [] # 修改变量名以清晰表示存储的是ID + inactive_subheartflows_ids = [] # 修改变量名以清晰表示存储的是ID # 检查所有子心流 # 使用 list(self._subheartflows.items()) 避免在迭代时修改字典 @@ -104,7 +106,7 @@ class Heartflow: # await self.do_a_thinking() # await asyncio.sleep(global_config.heart_flow_update_interval * 3) # 5分钟思考一次 - + await asyncio.sleep(300) async def heartflow_start_working(self): @@ -253,7 +255,7 @@ class Heartflow: # 创建并初始化观察对象 logger.debug(f"为 {subheartflow_id} 创建 observation") observation = ChattingObservation(subheartflow_id) - await observation.initialize() # 等待初始化完成 + await observation.initialize() # 等待初始化完成 subheartflow.add_observation(observation) logger.debug(f"为 {subheartflow_id} 添加 observation 成功") @@ -269,7 +271,7 @@ class Heartflow: except Exception as e: # 记录详细错误信息 logger.error(f"创建 subheartflow {subheartflow_id} 失败: {e}") - logger.error(traceback.format_exc()) # 记录完整的 traceback + logger.error(traceback.format_exc()) # 记录完整的 traceback # 考虑是否需要更具体的错误处理或资源清理逻辑 return None diff --git a/src/heart_flow/sub_heartflow.py b/src/heart_flow/sub_heartflow.py index c1a58dcd..9087b576 100644 --- a/src/heart_flow/sub_heartflow.py +++ b/src/heart_flow/sub_heartflow.py @@ -5,7 +5,6 @@ from src.plugins.models.utils_model import LLMRequest from src.config.config import global_config import time from typing import Optional, List -from datetime import datetime import traceback from src.plugins.chat.utils import parse_text_timestamps @@ -76,14 +75,14 @@ class SubHeartflow: ) self.main_heartflow_info = "" - + self.last_active_time = time.time() # 添加最后激活时间 - self.should_stop = False # 添加停止标志 - self.task: Optional[asyncio.Task] = None # 添加 task 属性 + self.should_stop = False # 添加停止标志 + self.task: Optional[asyncio.Task] = None # 添加 task 属性 self.is_active = False - self.observations: List[ChattingObservation] = [] # 使用 List 类型提示 + self.observations: List[ChattingObservation] = [] # 使用 List 类型提示 self.running_knowledges = [] @@ -98,7 +97,7 @@ class SubHeartflow: # 检查是否被主心流标记为停止 if self.should_stop: logger.info(f"子心流 {self.subheartflow_id} 被标记为停止，正在退出后台任务...") - break # 退出循环以停止任务 + break # 退出循环以停止任务 await asyncio.sleep(global_config.sub_heart_flow_update_interval) # 定期检查销毁条件 diff --git a/src/main.py b/src/main.py index aad08b90..f113a732 100644 --- a/src/main.py +++ b/src/main.py @@ -19,6 +19,7 @@ from .individuality.individuality import Individuality from .common.server import global_server from .plugins.chat_module.heartFC_chat.interest import InterestManager from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFC_Controller +from .plugins.chat_module.heartFC_chat.reasoning_chat import ReasoningChat logger = get_module_logger("main") @@ -117,8 +118,11 @@ class MainSystem: await interest_manager.start_background_tasks() logger.success("兴趣管理器后台任务启动成功") - # 初始化并独立启动 HeartFC_Chat - HeartFC_Controller() + # 初始化 ReasoningChat 单例 (确保它在需要之前被创建) + ReasoningChat.get_instance() + logger.success("ReasoningChat 单例初始化成功") + + # 初始化并独立启动 HeartFC_Chat 控制器 (使用 get_instance 获取单例) heartfc_chat_instance = HeartFC_Controller.get_instance() if heartfc_chat_instance: await heartfc_chat_instance.start() diff --git a/src/plugins/chat/bot.py b/src/plugins/chat/bot.py index c3ba78b0..eaf82997 100644 --- a/src/plugins/chat/bot.py +++ b/src/plugins/chat/bot.py @@ -123,8 +123,6 @@ class ChatBot: await self.heartFC_processor.process_message(message_data) else: await self.heartFC_processor.process_message(message_data) - - if template_group_name: async with global_prompt_manager.async_message_scope(template_group_name): diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py index 389e030a..55790eb4 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py @@ -13,6 +13,7 @@ from src.do_tool.tool_use import ToolUser from .interest import InterestManager from src.plugins.chat.chat_stream import chat_manager from .pf_chatting import PFChatting +import threading # 导入 threading # 定义日志配置 chat_config = LogConfig( @@ -27,43 +28,58 @@ INTEREST_MONITOR_INTERVAL_SECONDS = 1 class HeartFC_Controller: - _instance = None # For potential singleton access if needed by MessageManager + _instance = None + _lock = threading.Lock() # 使用 threading.Lock 替代 asyncio.Lock 以兼容 __new__ + _initialized = False - def __init__(self): - # --- Updated Init --- - if HeartFC_Controller._instance is not None: - # Prevent re-initialization if used as a singleton - return - self.gpt = ResponseGenerator() - self.mood_manager = MoodManager.get_instance() - self.mood_manager.start_mood_update() - self.tool_user = ToolUser() - self.interest_manager = InterestManager() - self._interest_monitor_task: Optional[asyncio.Task] = None - # --- New PFChatting Management --- - self.pf_chatting_instances: Dict[str, PFChatting] = {} - self._pf_chatting_lock = Lock() - # --- End New PFChatting Management --- - HeartFC_Controller._instance = self # Register instance - # --- End Updated Init --- - # --- Make dependencies accessible for PFChatting --- - # These are accessed via the passed instance in PFChatting - self.emoji_manager = emoji_manager - self.relationship_manager = relationship_manager - self.MessageManager = MessageManager # Pass the class/singleton access - # --- End dependencies --- - - # --- Added Class Method for Singleton Access --- - @classmethod - def get_instance(cls): + def __new__(cls, *args, **kwargs): if cls._instance is None: - # This might indicate an issue if called before initialization - logger.warning("HeartFC_Controller get_instance called before initialization.") - # Optionally, initialize here if a strict singleton pattern is desired - # cls._instance = cls() + with cls._lock: + if cls._instance is None: + cls._instance = super().__new__(cls) return cls._instance - # --- End Added Class Method --- + def __init__(self): + if self._initialized: + return + with self.__class__._lock: # 使用类锁确保初始化线程安全 + if self._initialized: + return + logger.info("正在初始化 HeartFC_Controller 单例...") + self.gpt = ResponseGenerator() + self.mood_manager = MoodManager.get_instance() + self.mood_manager.start_mood_update() + self.tool_user = ToolUser() + self.interest_manager = InterestManager() + self._interest_monitor_task: Optional[asyncio.Task] = None + self.pf_chatting_instances: Dict[str, PFChatting] = {} + self._pf_chatting_lock = Lock() # 这个可以是 asyncio.Lock，用于异步上下文 + self.emoji_manager = emoji_manager + self.relationship_manager = relationship_manager + self.MessageManager = MessageManager + self._initialized = True + logger.info("HeartFC_Controller 单例初始化完成。") + + @classmethod + def get_instance(cls): + """获取 HeartFC_Controller 的单例实例。""" + if cls._instance is None: + logger.warning("HeartFC_Controller 实例在首次 get_instance 时创建，可能未在 main 中正确初始化。") + cls() # 调用构造函数创建 + return cls._instance + + # --- 新增：检查 PFChatting 状态的方法 --- # + def is_pf_chatting_active(self, stream_id: str) -> bool: + """检查指定 stream_id 的 PFChatting 循环是否处于活动状态。""" + # 注意：这里直接访问字典，不加锁，因为读取通常是安全的， + # 并且 PFChatting 实例的 _loop_active 状态由其自身的异步循环管理。 + # 如果需要更强的保证，可以在访问 pf_instance 前获取 _pf_chatting_lock + pf_instance = self.pf_chatting_instances.get(stream_id) + if pf_instance and pf_instance._loop_active: # 直接检查 PFChatting 实例的 _loop_active 属性 + return True + return False + + # --- 结束新增 --- # async def start(self): """启动异步任务,如回复启动器""" diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py index 37708a94..38c68779 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py @@ -13,6 +13,7 @@ from ...chat.message_buffer import message_buffer from ...utils.timer_calculater import Timer from .interest import InterestManager from src.plugins.person_info.relationship_manager import relationship_manager +from .reasoning_chat import ReasoningChat # 定义日志配置 processor_config = LogConfig( @@ -29,7 +30,7 @@ class HeartFC_Processor: def __init__(self): self.storage = MessageStorage() self.interest_manager = InterestManager() - # self.chat_instance = chat_instance # 持有 HeartFC_Chat 实例 + self.reasoning_chat = ReasoningChat.get_instance() async def process_message(self, message_data: str) -> None: """处理接收到的原始消息数据，完成消息解析、缓冲、过滤、存储、兴趣度计算与更新等核心流程。 @@ -72,11 +73,11 @@ class HeartFC_Processor: user_info=userinfo, group_info=groupinfo, ) - if not chat: - logger.error( - f"无法为消息创建或获取聊天流: user {userinfo.user_id}, group {groupinfo.group_id if groupinfo else 'None'}" - ) - return + + # --- 添加兴趣追踪启动 --- + # 在获取到 chat 对象后，启动对该聊天流的兴趣监控 + await self.reasoning_chat.start_monitoring_interest(chat) + # --- 结束添加 --- message.update_chat_stream(chat) @@ -90,7 +91,6 @@ class HeartFC_Processor: message.raw_message, chat, userinfo ): return - logger.trace(f"过滤词/正则表达式过滤成功: {message.processed_plain_text}") # 查询缓冲器结果 buffer_result = await message_buffer.query_buffer_result(message) @@ -152,6 +152,8 @@ class HeartFC_Processor: f"使用激活率 {interested_rate:.2f} 更新后 (通过缓冲后)，当前兴趣度: {current_interest:.2f}" ) + self.interest_manager.add_interest_dict(message, interested_rate, is_mentioned) + except Exception as e: logger.error(f"更新兴趣度失败: {e}") # 调整日志消息 logger.error(traceback.format_exc()) diff --git a/src/plugins/chat_module/heartFC_chat/interest.py b/src/plugins/chat_module/heartFC_chat/interest.py index 5a961e91..4ac5498a 100644 --- a/src/plugins/chat_module/heartFC_chat/interest.py +++ b/src/plugins/chat_module/heartFC_chat/interest.py @@ -6,6 +6,7 @@ import json # 引入 json import os # 引入 os from typing import Optional # <--- 添加导入 import random # <--- 添加导入 random +from src.plugins.chat.message import MessageRecv from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG from src.plugins.chat.chat_stream import chat_manager # *** Import ChatManager *** @@ -66,6 +67,13 @@ class InterestChatting: self.is_above_threshold: bool = False # 标记兴趣值是否高于阈值 # --- 结束：概率回复相关属性 --- + # 记录激发兴趣对(消息id,激活值) + self.interest_dict = {} + + def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool): + # Store the MessageRecv object and the interest value as a tuple + self.interest_dict[message.message_info.message_id] = (message, interest_value, is_mentioned) + def _calculate_decay(self, current_time: float): """计算从上次更新到现在的衰减""" time_delta = current_time - self.last_update_time @@ -445,6 +453,10 @@ class InterestManager: stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 logger.warning(f"尝试降低不存在的聊天流 {stream_name} 的兴趣度") + def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool): + interest_chatting = self._get_or_create_interest_chatting(message.chat_stream.stream_id) + interest_chatting.add_interest_dict(message, interest_value, is_mentioned) + def cleanup_inactive_chats(self, max_age_seconds=INACTIVE_THRESHOLD_SECONDS): """ 清理长时间不活跃的聊天流记录 diff --git a/src/plugins/chat_module/heartFC_chat/reasoning_chat.py b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py new file mode 100644 index 00000000..95d3641d --- /dev/null +++ b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py @@ -0,0 +1,412 @@ +import time +import threading # 导入 threading +from random import random +import traceback +import asyncio +from typing import List, Dict +from ...moods.moods import MoodManager +from ....config.config import global_config +from ...chat.emoji_manager import emoji_manager +from .reasoning_generator import ResponseGenerator +from ...chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet +from ...chat.messagesender import message_manager +from ...storage.storage import MessageStorage +from ...chat.utils import is_mentioned_bot_in_message +from ...chat.utils_image import image_path_to_base64 +from ...willing.willing_manager import willing_manager +from ...message import UserInfo, Seg +from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig +from src.plugins.chat.chat_stream import ChatStream +from src.plugins.person_info.relationship_manager import relationship_manager +from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager +from src.plugins.utils.timer_calculater import Timer +from .interest import InterestManager +from .heartFC_controler import HeartFC_Controller # 导入 HeartFC_Controller + +# 定义日志配置 +chat_config = LogConfig( + console_format=CHAT_STYLE_CONFIG["console_format"], + file_format=CHAT_STYLE_CONFIG["file_format"], +) + +logger = get_module_logger("reasoning_chat", config=chat_config) + + +class ReasoningChat: + _instance = None + _lock = threading.Lock() + _initialized = False + + def __new__(cls, *args, **kwargs): + if cls._instance is None: + with cls._lock: + # Double-check locking + if cls._instance is None: + cls._instance = super().__new__(cls) + return cls._instance + + def __init__(self): + # 防止重复初始化 + if self._initialized: + return + with self.__class__._lock: # 使用类锁确保线程安全 + if self._initialized: + return + logger.info("正在初始化 ReasoningChat 单例...") # 添加日志 + self.storage = MessageStorage() + self.gpt = ResponseGenerator() + self.mood_manager = MoodManager.get_instance() + self.mood_manager.start_mood_update() + # 用于存储每个 chat stream 的兴趣监控任务 + self._interest_monitoring_tasks: Dict[str, asyncio.Task] = {} + self._initialized = True + self.interest_manager = InterestManager() + logger.info("ReasoningChat 单例初始化完成。") # 添加日志 + + @classmethod + def get_instance(cls): + """获取 ReasoningChat 的单例实例。""" + if cls._instance is None: + # 如果实例还未创建（理论上应该在 main 中初始化，但作为备用） + logger.warning("ReasoningChat 实例在首次 get_instance 时创建。") + cls() # 调用构造函数来创建实例 + return cls._instance + + @staticmethod + async def _create_thinking_message(message, chat, userinfo, messageinfo): + """创建思考消息""" + bot_user_info = UserInfo( + user_id=global_config.BOT_QQ, + user_nickname=global_config.BOT_NICKNAME, + platform=messageinfo.platform, + ) + + thinking_time_point = round(time.time(), 2) + thinking_id = "mt" + str(thinking_time_point) + thinking_message = MessageThinking( + message_id=thinking_id, + chat_stream=chat, + bot_user_info=bot_user_info, + reply=message, + thinking_start_time=thinking_time_point, + ) + + message_manager.add_message(thinking_message) + + return thinking_id + + @staticmethod + async def _send_response_messages(message, chat, response_set: List[str], thinking_id) -> MessageSending: + """发送回复消息""" + container = message_manager.get_container(chat.stream_id) + thinking_message = None + + for msg in container.messages: + if isinstance(msg, MessageThinking) and msg.message_info.message_id == thinking_id: + thinking_message = msg + container.messages.remove(msg) + break + + if not thinking_message: + logger.warning("未找到对应的思考消息，可能已超时被移除") + return + + thinking_start_time = thinking_message.thinking_start_time + message_set = MessageSet(chat, thinking_id) + + mark_head = False + first_bot_msg = None + for msg in response_set: + message_segment = Seg(type="text", data=msg) + bot_message = MessageSending( + message_id=thinking_id, + chat_stream=chat, + bot_user_info=UserInfo( + user_id=global_config.BOT_QQ, + user_nickname=global_config.BOT_NICKNAME, + platform=message.message_info.platform, + ), + sender_info=message.message_info.user_info, + message_segment=message_segment, + reply=message, + is_head=not mark_head, + is_emoji=False, + thinking_start_time=thinking_start_time, + ) + if not mark_head: + mark_head = True + first_bot_msg = bot_message + message_set.add_message(bot_message) + message_manager.add_message(message_set) + + return first_bot_msg + + @staticmethod + async def _handle_emoji(message, chat, response): + """处理表情包""" + if random() < global_config.emoji_chance: + emoji_raw = await emoji_manager.get_emoji_for_text(response) + if emoji_raw: + emoji_path, description = emoji_raw + emoji_cq = image_path_to_base64(emoji_path) + + thinking_time_point = round(message.message_info.time, 2) + + message_segment = Seg(type="emoji", data=emoji_cq) + bot_message = MessageSending( + message_id="mt" + str(thinking_time_point), + chat_stream=chat, + bot_user_info=UserInfo( + user_id=global_config.BOT_QQ, + user_nickname=global_config.BOT_NICKNAME, + platform=message.message_info.platform, + ), + sender_info=message.message_info.user_info, + message_segment=message_segment, + reply=message, + is_head=False, + is_emoji=True, + ) + message_manager.add_message(bot_message) + + async def _update_relationship(self, message: MessageRecv, response_set): + """更新关系情绪""" + ori_response = ",".join(response_set) + stance, emotion = await self.gpt._get_emotion_tags(ori_response, message.processed_plain_text) + await relationship_manager.calculate_update_relationship_value( + chat_stream=message.chat_stream, label=emotion, stance=stance + ) + self.mood_manager.update_mood_from_emotion(emotion, global_config.mood_intensity_factor) + + async def _find_interested_message(self, chat: ChatStream) -> None: + # 此函数设计为后台任务，轮询指定 chat 的兴趣消息。 + # 它通常由外部代码在 chat 流活跃时启动。 + controller = HeartFC_Controller.get_instance() # 获取控制器实例 + if not controller: + logger.error(f"无法获取 HeartFC_Controller 实例，无法检查 PFChatting 状态。stream: {chat.stream_id}") + # 在没有控制器的情况下可能需要决定是继续处理还是完全停止？这里暂时假设继续 + pass # 或者 return? + + while True: + await asyncio.sleep(1) # 每秒检查一次 + interest_chatting = self.interest_manager.get_interest_chatting(chat.stream_id) + + if not interest_chatting: + continue + + interest_dict = interest_chatting.interest_dict if interest_chatting.interest_dict else {} + items_to_process = list(interest_dict.items()) + + if not items_to_process: + continue + + for msg_id, (message, interest_value, is_mentioned) in items_to_process: + # --- 检查 PFChatting 是否活跃 --- # + pf_active = False + if controller: + pf_active = controller.is_pf_chatting_active(chat.stream_id) + + if pf_active: + # 如果 PFChatting 活跃，则跳过处理，直接移除消息 + removed_item = interest_dict.pop(msg_id, None) + if removed_item: + logger.debug(f"PFChatting 活跃，已跳过并移除兴趣消息 {msg_id} for stream: {chat.stream_id}") + continue # 处理下一条消息 + # --- 结束检查 --- # + + # 只有当 PFChatting 不活跃时才执行以下处理逻辑 + try: + # logger.debug(f"正在处理消息 {msg_id} for stream: {chat.stream_id}") # 可选调试信息 + await self.normal_reasoning_chat( + message=message, + chat=chat, + is_mentioned=is_mentioned, + interested_rate=interest_value, + ) + # logger.debug(f"处理完成消息 {msg_id}") # 可选调试信息 + except Exception as e: + logger.error(f"处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}") + finally: + # 无论处理成功与否（且PFChatting不活跃），都尝试从原始字典中移除该消息 + removed_item = interest_dict.pop(msg_id, None) + if removed_item: + logger.debug(f"已从兴趣字典中移除消息 {msg_id}") + + async def normal_reasoning_chat( + self, message: MessageRecv, chat: ChatStream, is_mentioned: bool, interested_rate: float + ) -> None: + timing_results = {} + userinfo = message.message_info.user_info + messageinfo = message.message_info + + is_mentioned, reply_probability = is_mentioned_bot_in_message(message) + # 意愿管理器：设置当前message信息 + willing_manager.setup(message, chat, is_mentioned, interested_rate) + + # 获取回复概率 + is_willing = False + if reply_probability != 1: + is_willing = True + reply_probability = await willing_manager.get_reply_probability(message.message_info.message_id) + + if message.message_info.additional_config: + if "maimcore_reply_probability_gain" in message.message_info.additional_config.keys(): + reply_probability += message.message_info.additional_config["maimcore_reply_probability_gain"] + + # 打印消息信息 + mes_name = chat.group_info.group_name if chat.group_info else "私聊" + current_time = time.strftime("%H:%M:%S", time.localtime(message.message_info.time)) + willing_log = f"[回复意愿:{await willing_manager.get_willing(chat.stream_id):.2f}]" if is_willing else "" + logger.info( + f"[{current_time}][{mes_name}]" + f"{chat.user_info.user_nickname}:" + f"{message.processed_plain_text}{willing_log}[概率:{reply_probability * 100:.1f}%]" + ) + do_reply = False + if random() < reply_probability: + do_reply = True + + # 回复前处理 + await willing_manager.before_generate_reply_handle(message.message_info.message_id) + + # 创建思考消息 + with Timer("创建思考消息", timing_results): + thinking_id = await self._create_thinking_message(message, chat, userinfo, messageinfo) + + logger.debug(f"创建捕捉器，thinking_id:{thinking_id}") + + info_catcher = info_catcher_manager.get_info_catcher(thinking_id) + info_catcher.catch_decide_to_response(message) + + # 生成回复 + try: + with Timer("生成回复", timing_results): + response_set = await self.gpt.generate_response(message, thinking_id) + + info_catcher.catch_after_generate_response(timing_results["生成回复"]) + except Exception as e: + logger.error(f"回复生成出现错误：{str(e)} {traceback.format_exc()}") + response_set = None + + if not response_set: + logger.info("为什么生成回复失败？") + return + + # 发送消息 + with Timer("发送消息", timing_results): + first_bot_msg = await self._send_response_messages(message, chat, response_set, thinking_id) + + info_catcher.catch_after_response(timing_results["发送消息"], response_set, first_bot_msg) + + info_catcher.done_catch() + + # 处理表情包 + with Timer("处理表情包", timing_results): + await self._handle_emoji(message, chat, response_set) + + # 更新关系情绪 + with Timer("更新关系情绪", timing_results): + await self._update_relationship(message, response_set) + + # 回复后处理 + await willing_manager.after_generate_reply_handle(message.message_info.message_id) + + # 输出性能计时结果 + if do_reply: + timing_str = " | ".join([f"{step}: {duration:.2f}秒" for step, duration in timing_results.items()]) + trigger_msg = message.processed_plain_text + response_msg = " ".join(response_set) if response_set else "无回复" + logger.info(f"触发消息: {trigger_msg[:20]}... | 推理消息: {response_msg[:20]}... | 性能计时: {timing_str}") + else: + # 不回复处理 + await willing_manager.not_reply_handle(message.message_info.message_id) + + # 意愿管理器：注销当前message信息 + willing_manager.delete(message.message_info.message_id) + + @staticmethod + def _check_ban_words(text: str, chat, userinfo) -> bool: + """检查消息中是否包含过滤词""" + for word in global_config.ban_words: + if word in text: + logger.info( + f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}" + ) + logger.info(f"[过滤词识别]消息中含有{word}，filtered") + return True + return False + + @staticmethod + def _check_ban_regex(text: str, chat, userinfo) -> bool: + """检查消息是否匹配过滤正则表达式""" + for pattern in global_config.ban_msgs_regex: + if pattern.search(text): + logger.info( + f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}" + ) + logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered") + return True + return False + + async def start_monitoring_interest(self, chat: ChatStream): + """为指定的 ChatStream 启动后台兴趣消息监控任务。""" + stream_id = chat.stream_id + # 检查任务是否已在运行 + if stream_id in self._interest_monitoring_tasks and not self._interest_monitoring_tasks[stream_id].done(): + task = self._interest_monitoring_tasks[stream_id] + if not task.cancelled(): # 确保任务未被取消 + logger.info(f"兴趣监控任务已在运行 stream: {stream_id}") + return + else: + logger.info(f"发现已取消的任务，重新创建 stream: {stream_id}") + # 如果任务被取消了，允许重新创建 + + logger.info(f"启动兴趣监控任务 stream: {stream_id}...") + # 创建新的后台任务来运行 _find_interested_message + task = asyncio.create_task(self._find_interested_message(chat)) + self._interest_monitoring_tasks[stream_id] = task + + # 添加回调，当任务完成（或被取消）时，自动从字典中移除 + task.add_done_callback(lambda t: self._handle_task_completion(stream_id, t)) + + def _handle_task_completion(self, stream_id: str, task: asyncio.Task): + """处理监控任务完成的回调。""" + try: + # 检查任务是否因异常而结束 + exception = task.exception() + if exception: + logger.error(f"兴趣监控任务 stream {stream_id} 异常结束: {exception}", exc_info=exception) + elif task.cancelled(): + logger.info(f"兴趣监控任务 stream {stream_id} 已被取消。") + else: + logger.info(f"兴趣监控任务 stream {stream_id} 正常结束。") # 理论上 while True 不会正常结束 + except asyncio.CancelledError: + logger.info(f"兴趣监控任务 stream {stream_id} 在完成处理期间被取消。") + finally: + # 无论如何都从字典中移除 + removed_task = self._interest_monitoring_tasks.pop(stream_id, None) + if removed_task: + logger.debug(f"已从监控任务字典移除 stream: {stream_id}") + + async def stop_monitoring_interest(self, stream_id: str): + """停止指定 stream_id 的兴趣消息监控任务。""" + if stream_id in self._interest_monitoring_tasks: + task = self._interest_monitoring_tasks[stream_id] + if not task.done(): + logger.info(f"正在停止兴趣监控任务 stream: {stream_id}...") + task.cancel() # 请求取消任务 + try: + # 等待任务实际被取消（可选，提供更明确的停止） + # 设置超时以防万一 + await asyncio.wait_for(task, timeout=5.0) + except asyncio.CancelledError: + logger.info(f"兴趣监控任务 stream {stream_id} 已确认取消。") + except asyncio.TimeoutError: + logger.warning(f"停止兴趣监控任务 stream {stream_id} 超时。任务可能仍在运行。") + except Exception as e: + # 捕获 task.exception() 可能在取消期间重新引发的错误 + logger.error(f"停止兴趣监控任务 stream {stream_id} 时发生错误: {e}") + # 任务最终会由 done_callback 移除，或在这里再次确认移除 + self._interest_monitoring_tasks.pop(stream_id, None) + else: + logger.warning(f"尝试停止不存在或已停止的监控任务 stream: {stream_id}") diff --git a/src/plugins/chat_module/heartFC_chat/reasoning_generator.py b/src/plugins/chat_module/heartFC_chat/reasoning_generator.py new file mode 100644 index 00000000..2f4ba06e --- /dev/null +++ b/src/plugins/chat_module/heartFC_chat/reasoning_generator.py @@ -0,0 +1,199 @@ +from typing import List, Optional, Tuple, Union +import random + +from ...models.utils_model import LLMRequest +from ....config.config import global_config +from ...chat.message import MessageThinking +from .reasoning_prompt_builder import prompt_builder +from ...chat.utils import process_llm_response +from ...utils.timer_calculater import Timer +from src.common.logger import get_module_logger, LogConfig, LLM_STYLE_CONFIG +from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager + +# 定义日志配置 +llm_config = LogConfig( + # 使用消息发送专用样式 + console_format=LLM_STYLE_CONFIG["console_format"], + file_format=LLM_STYLE_CONFIG["file_format"], +) + +logger = get_module_logger("llm_generator", config=llm_config) + + +class ResponseGenerator: + def __init__(self): + self.model_reasoning = LLMRequest( + model=global_config.llm_reasoning, + temperature=0.7, + max_tokens=3000, + request_type="response_reasoning", + ) + self.model_normal = LLMRequest( + model=global_config.llm_normal, + temperature=global_config.llm_normal["temp"], + max_tokens=256, + request_type="response_reasoning", + ) + + self.model_sum = LLMRequest( + model=global_config.llm_summary_by_topic, temperature=0.7, max_tokens=3000, request_type="relation" + ) + self.current_model_type = "r1" # 默认使用 R1 + self.current_model_name = "unknown model" + + async def generate_response(self, message: MessageThinking, thinking_id: str) -> Optional[Union[str, List[str]]]: + """根据当前模型类型选择对应的生成函数""" + # 从global_config中获取模型概率值并选择模型 + if random.random() < global_config.model_reasoning_probability: + self.current_model_type = "深深地" + current_model = self.model_reasoning + else: + self.current_model_type = "浅浅的" + current_model = self.model_normal + + logger.info( + f"{self.current_model_type}思考:{message.processed_plain_text[:30] + '...' if len(message.processed_plain_text) > 30 else message.processed_plain_text}" + ) # noqa: E501 + + model_response = await self._generate_response_with_model(message, current_model, thinking_id) + + # print(f"raw_content: {model_response}") + + if model_response: + logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response}") + model_response = await self._process_response(model_response) + + return model_response + else: + logger.info(f"{self.current_model_type}思考，失败") + return None + + async def _generate_response_with_model(self, message: MessageThinking, model: LLMRequest, thinking_id: str): + info_catcher = info_catcher_manager.get_info_catcher(thinking_id) + + if message.chat_stream.user_info.user_cardname and message.chat_stream.user_info.user_nickname: + sender_name = ( + f"[({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}]" + f"{message.chat_stream.user_info.user_cardname}" + ) + elif message.chat_stream.user_info.user_nickname: + sender_name = f"({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}" + else: + sender_name = f"用户({message.chat_stream.user_info.user_id})" + + logger.debug("开始使用生成回复-2") + # 构建prompt + with Timer() as t_build_prompt: + prompt = await prompt_builder._build_prompt( + message.chat_stream, + message_txt=message.processed_plain_text, + sender_name=sender_name, + stream_id=message.chat_stream.stream_id, + ) + logger.info(f"构建prompt时间: {t_build_prompt.human_readable}") + + try: + content, reasoning_content, self.current_model_name = await model.generate_response(prompt) + + info_catcher.catch_after_llm_generated( + prompt=prompt, response=content, reasoning_content=reasoning_content, model_name=self.current_model_name + ) + + except Exception: + logger.exception("生成回复时出错") + return None + + # 保存到数据库 + # self._save_to_db( + # message=message, + # sender_name=sender_name, + # prompt=prompt, + # content=content, + # reasoning_content=reasoning_content, + # # reasoning_content_check=reasoning_content_check if global_config.enable_kuuki_read else "" + # ) + + return content + + # def _save_to_db( + # self, + # message: MessageRecv, + # sender_name: str, + # prompt: str, + # content: str, + # reasoning_content: str, + # ): + # """保存对话记录到数据库""" + # db.reasoning_logs.insert_one( + # { + # "time": time.time(), + # "chat_id": message.chat_stream.stream_id, + # "user": sender_name, + # "message": message.processed_plain_text, + # "model": self.current_model_name, + # "reasoning": reasoning_content, + # "response": content, + # "prompt": prompt, + # } + # ) + + async def _get_emotion_tags(self, content: str, processed_plain_text: str): + """提取情感标签，结合立场和情绪""" + try: + # 构建提示词，结合回复内容、被回复的内容以及立场分析 + prompt = f""" + 请严格根据以下对话内容，完成以下任务： + 1. 判断回复者对被回复者观点的直接立场： + - "支持"：明确同意或强化被回复者观点 + - "反对"：明确反驳或否定被回复者观点 + - "中立"：不表达明确立场或无关回应 + 2. 从"开心,愤怒,悲伤,惊讶,平静,害羞,恐惧,厌恶,困惑"中选出最匹配的1个情感标签 + 3. 按照"立场-情绪"的格式直接输出结果，例如："反对-愤怒" + 4. 考虑回复者的人格设定为{global_config.personality_core} + + 对话示例： + 被回复：「A就是笨」 + 回复：「A明明很聪明」 → 反对-愤怒 + + 当前对话： + 被回复：「{processed_plain_text}」 + 回复：「{content}」 + + 输出要求： + - 只需输出"立场-情绪"结果，不要解释 + - 严格基于文字直接表达的对立关系判断 + """ + + # 调用模型生成结果 + result, _, _ = await self.model_sum.generate_response(prompt) + result = result.strip() + + # 解析模型输出的结果 + if "-" in result: + stance, emotion = result.split("-", 1) + valid_stances = ["支持", "反对", "中立"] + valid_emotions = ["开心", "愤怒", "悲伤", "惊讶", "害羞", "平静", "恐惧", "厌恶", "困惑"] + if stance in valid_stances and emotion in valid_emotions: + return stance, emotion # 返回有效的立场-情绪组合 + else: + logger.debug(f"无效立场-情感组合:{result}") + return "中立", "平静" # 默认返回中立-平静 + else: + logger.debug(f"立场-情感格式错误:{result}") + return "中立", "平静" # 格式错误时返回默认值 + + except Exception as e: + logger.debug(f"获取情感标签时出错: {e}") + return "中立", "平静" # 出错时返回默认值 + + @staticmethod + async def _process_response(content: str) -> Tuple[List[str], List[str]]: + """处理响应内容，返回处理后的内容和情感标签""" + if not content: + return None, [] + + processed_response = process_llm_response(content) + + # print(f"得到了处理后的llm返回{processed_response}") + + return processed_response diff --git a/src/plugins/chat_module/heartFC_chat/reasoning_prompt_builder.py b/src/plugins/chat_module/heartFC_chat/reasoning_prompt_builder.py new file mode 100644 index 00000000..d37d6545 --- /dev/null +++ b/src/plugins/chat_module/heartFC_chat/reasoning_prompt_builder.py @@ -0,0 +1,445 @@ +import random +import time +from typing import Optional, Union + +from ....common.database import db +from ...chat.utils import get_embedding, get_recent_group_detailed_plain_text, get_recent_group_speaker +from ...chat.chat_stream import chat_manager +from ...moods.moods import MoodManager +from ....individuality.individuality import Individuality +from ...memory_system.Hippocampus import HippocampusManager +from ...schedule.schedule_generator import bot_schedule +from ....config.config import global_config +from ...person_info.relationship_manager import relationship_manager +from src.common.logger import get_module_logger +from src.plugins.utils.prompt_builder import Prompt, global_prompt_manager + +logger = get_module_logger("prompt") + + +def init_prompt(): + Prompt( + """ +{relation_prompt_all} +{memory_prompt} +{prompt_info} +{schedule_prompt} +{chat_target} +{chat_talking_prompt} +现在"{sender_name}"说的:{message_txt}。引起了你的注意，你想要在群里发言发言或者回复这条消息。\n +你的网名叫{bot_name}，有人也叫你{bot_other_names}，{prompt_personality}。 +你正在{chat_target_2},现在请你读读之前的聊天记录，{mood_prompt}，然后给出日常且口语化的回复，平淡一些， +尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。{prompt_ger} +请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景，尽量不要说你说过的话 +请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 +{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""", + "reasoning_prompt_main", + ) + Prompt( + "{relation_prompt}关系等级越大，关系越好，请分析聊天记录，根据你和说话者{sender_name}的关系和态度进行回复，明确你的立场和情感。", + "relationship_prompt", + ) + Prompt( + "你想起你之前见过的事情：{related_memory_info}。\n以上是你的回忆，不一定是目前聊天里的人说的，也不一定是现在发生的事情，请记住。\n", + "memory_prompt", + ) + Prompt("你现在正在做的事情是：{schedule_info}", "schedule_prompt") + Prompt("\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n", "knowledge_prompt") + + +class PromptBuilder: + def __init__(self): + self.prompt_built = "" + self.activate_messages = "" + + async def _build_prompt( + self, chat_stream, message_txt: str, sender_name: str = "某人", stream_id: Optional[int] = None + ) -> tuple[str, str]: + # 开始构建prompt + prompt_personality = "你" + # person + individuality = Individuality.get_instance() + + personality_core = individuality.personality.personality_core + prompt_personality += personality_core + + personality_sides = individuality.personality.personality_sides + random.shuffle(personality_sides) + prompt_personality += f",{personality_sides[0]}" + + identity_detail = individuality.identity.identity_detail + random.shuffle(identity_detail) + prompt_personality += f",{identity_detail[0]}" + + # 关系 + who_chat_in_group = [ + (chat_stream.user_info.platform, chat_stream.user_info.user_id, chat_stream.user_info.user_nickname) + ] + who_chat_in_group += get_recent_group_speaker( + stream_id, + (chat_stream.user_info.platform, chat_stream.user_info.user_id), + limit=global_config.MAX_CONTEXT_SIZE, + ) + + relation_prompt = "" + for person in who_chat_in_group: + relation_prompt += await relationship_manager.build_relationship_info(person) + + # relation_prompt_all = ( + # f"{relation_prompt}关系等级越大，关系越好，请分析聊天记录，" + # f"根据你和说话者{sender_name}的关系和态度进行回复，明确你的立场和情感。" + # ) + + # 心情 + mood_manager = MoodManager.get_instance() + mood_prompt = mood_manager.get_prompt() + + # logger.info(f"心情prompt: {mood_prompt}") + + # 调取记忆 + memory_prompt = "" + related_memory = await HippocampusManager.get_instance().get_memory_from_text( + text=message_txt, max_memory_num=2, max_memory_length=2, max_depth=3, fast_retrieval=False + ) + related_memory_info = "" + if related_memory: + for memory in related_memory: + related_memory_info += memory[1] + # memory_prompt = f"你想起你之前见过的事情：{related_memory_info}。\n以上是你的回忆，不一定是目前聊天里的人说的，也不一定是现在发生的事情，请记住。\n" + memory_prompt = await global_prompt_manager.format_prompt( + "memory_prompt", related_memory_info=related_memory_info + ) + + # print(f"相关记忆：{related_memory_info}") + + # 日程构建 + # schedule_prompt = f"""你现在正在做的事情是：{bot_schedule.get_current_num_task(num=1, time_info=False)}""" + + # 获取聊天上下文 + chat_in_group = True + chat_talking_prompt = "" + if stream_id: + chat_talking_prompt = get_recent_group_detailed_plain_text( + stream_id, limit=global_config.MAX_CONTEXT_SIZE, combine=True + ) + chat_stream = chat_manager.get_stream(stream_id) + if chat_stream.group_info: + chat_talking_prompt = chat_talking_prompt + else: + chat_in_group = False + chat_talking_prompt = chat_talking_prompt + # print(f"\033[1;34m[调试]\033[0m 已从数据库获取群 {group_id} 的消息记录:{chat_talking_prompt}") + # 关键词检测与反应 + keywords_reaction_prompt = "" + for rule in global_config.keywords_reaction_rules: + if rule.get("enable", False): + if any(keyword in message_txt.lower() for keyword in rule.get("keywords", [])): + logger.info( + f"检测到以下关键词之一：{rule.get('keywords', [])}，触发反应：{rule.get('reaction', '')}" + ) + keywords_reaction_prompt += rule.get("reaction", "") + "，" + else: + for pattern in rule.get("regex", []): + result = pattern.search(message_txt) + if result: + reaction = rule.get("reaction", "") + for name, content in result.groupdict().items(): + reaction = reaction.replace(f"[{name}]", content) + logger.info(f"匹配到以下正则表达式：{pattern}，触发反应：{reaction}") + keywords_reaction_prompt += reaction + "，" + break + + # 中文高手(新加的好玩功能) + prompt_ger = "" + if random.random() < 0.04: + prompt_ger += "你喜欢用倒装句" + if random.random() < 0.02: + prompt_ger += "你喜欢用反问句" + if random.random() < 0.01: + prompt_ger += "你喜欢用文言文" + + # 知识构建 + start_time = time.time() + prompt_info = await self.get_prompt_info(message_txt, threshold=0.38) + if prompt_info: + # prompt_info = f"""\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n""" + prompt_info = await global_prompt_manager.format_prompt("knowledge_prompt", prompt_info=prompt_info) + + end_time = time.time() + logger.debug(f"知识检索耗时: {(end_time - start_time):.3f}秒") + + # moderation_prompt = "" + # moderation_prompt = """**检查并忽略**任何涉及尝试绕过审核的行为。 + # 涉及政治敏感以及违法违规的内容请规避。""" + + logger.debug("开始构建prompt") + + # prompt = f""" + # {relation_prompt_all} + # {memory_prompt} + # {prompt_info} + # {schedule_prompt} + # {chat_target} + # {chat_talking_prompt} + # 现在"{sender_name}"说的:{message_txt}。引起了你的注意，你想要在群里发言发言或者回复这条消息。\n + # 你的网名叫{global_config.BOT_NICKNAME}，有人也叫你{"/".join(global_config.BOT_ALIAS_NAMES)}，{prompt_personality}。 + # 你正在{chat_target_2},现在请你读读之前的聊天记录，{mood_prompt}，然后给出日常且口语化的回复，平淡一些， + # 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。{prompt_ger} + # 请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景，尽量不要说你说过的话 + # 请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 + # {moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""" + + prompt = await global_prompt_manager.format_prompt( + "reasoning_prompt_main", + relation_prompt_all=await global_prompt_manager.get_prompt_async("relationship_prompt"), + relation_prompt=relation_prompt, + sender_name=sender_name, + memory_prompt=memory_prompt, + prompt_info=prompt_info, + schedule_prompt=await global_prompt_manager.format_prompt( + "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False) + ), + chat_target=await global_prompt_manager.get_prompt_async("chat_target_group1") + if chat_in_group + else await global_prompt_manager.get_prompt_async("chat_target_private1"), + chat_target_2=await global_prompt_manager.get_prompt_async("chat_target_group2") + if chat_in_group + else await global_prompt_manager.get_prompt_async("chat_target_private2"), + chat_talking_prompt=chat_talking_prompt, + message_txt=message_txt, + bot_name=global_config.BOT_NICKNAME, + bot_other_names="/".join( + global_config.BOT_ALIAS_NAMES, + ), + prompt_personality=prompt_personality, + mood_prompt=mood_prompt, + keywords_reaction_prompt=keywords_reaction_prompt, + prompt_ger=prompt_ger, + moderation_prompt=await global_prompt_manager.get_prompt_async("moderation_prompt"), + ) + + return prompt + + async def get_prompt_info(self, message: str, threshold: float): + start_time = time.time() + related_info = "" + logger.debug(f"获取知识库内容，元消息：{message[:30]}...，消息长度: {len(message)}") + + # 1. 先从LLM获取主题，类似于记忆系统的做法 + topics = [] + # try: + # # 先尝试使用记忆系统的方法获取主题 + # hippocampus = HippocampusManager.get_instance()._hippocampus + # topic_num = min(5, max(1, int(len(message) * 0.1))) + # topics_response = await hippocampus.llm_topic_judge.generate_response(hippocampus.find_topic_llm(message, topic_num)) + + # # 提取关键词 + # topics = re.findall(r"<([^>]+)>", topics_response[0]) + # if not topics: + # topics = [] + # else: + # topics = [ + # topic.strip() + # for topic in ",".join(topics).replace("，", ",").replace("、", ",").replace(" ", ",").split(",") + # if topic.strip() + # ] + + # logger.info(f"从LLM提取的主题: {', '.join(topics)}") + # except Exception as e: + # logger.error(f"从LLM提取主题失败: {str(e)}") + # # 如果LLM提取失败，使用jieba分词提取关键词作为备选 + # words = jieba.cut(message) + # topics = [word for word in words if len(word) > 1][:5] + # logger.info(f"使用jieba提取的主题: {', '.join(topics)}") + + # 如果无法提取到主题，直接使用整个消息 + if not topics: + logger.info("未能提取到任何主题，使用整个消息进行查询") + embedding = await get_embedding(message, request_type="prompt_build") + if not embedding: + logger.error("获取消息嵌入向量失败") + return "" + + related_info = self.get_info_from_db(embedding, limit=3, threshold=threshold) + logger.info(f"知识库检索完成，总耗时: {time.time() - start_time:.3f}秒") + return related_info + + # 2. 对每个主题进行知识库查询 + logger.info(f"开始处理{len(topics)}个主题的知识库查询") + + # 优化：批量获取嵌入向量，减少API调用 + embeddings = {} + topics_batch = [topic for topic in topics if len(topic) > 0] + if message: # 确保消息非空 + topics_batch.append(message) + + # 批量获取嵌入向量 + embed_start_time = time.time() + for text in topics_batch: + if not text or len(text.strip()) == 0: + continue + + try: + embedding = await get_embedding(text, request_type="prompt_build") + if embedding: + embeddings[text] = embedding + else: + logger.warning(f"获取'{text}'的嵌入向量失败") + except Exception as e: + logger.error(f"获取'{text}'的嵌入向量时发生错误: {str(e)}") + + logger.info(f"批量获取嵌入向量完成，耗时: {time.time() - embed_start_time:.3f}秒") + + if not embeddings: + logger.error("所有嵌入向量获取失败") + return "" + + # 3. 对每个主题进行知识库查询 + all_results = [] + query_start_time = time.time() + + # 首先添加原始消息的查询结果 + if message in embeddings: + original_results = self.get_info_from_db(embeddings[message], limit=3, threshold=threshold, return_raw=True) + if original_results: + for result in original_results: + result["topic"] = "原始消息" + all_results.extend(original_results) + logger.info(f"原始消息查询到{len(original_results)}条结果") + + # 然后添加每个主题的查询结果 + for topic in topics: + if not topic or topic not in embeddings: + continue + + try: + topic_results = self.get_info_from_db(embeddings[topic], limit=3, threshold=threshold, return_raw=True) + if topic_results: + # 添加主题标记 + for result in topic_results: + result["topic"] = topic + all_results.extend(topic_results) + logger.info(f"主题'{topic}'查询到{len(topic_results)}条结果") + except Exception as e: + logger.error(f"查询主题'{topic}'时发生错误: {str(e)}") + + logger.info(f"知识库查询完成，耗时: {time.time() - query_start_time:.3f}秒，共获取{len(all_results)}条结果") + + # 4. 去重和过滤 + process_start_time = time.time() + unique_contents = set() + filtered_results = [] + for result in all_results: + content = result["content"] + if content not in unique_contents: + unique_contents.add(content) + filtered_results.append(result) + + # 5. 按相似度排序 + filtered_results.sort(key=lambda x: x["similarity"], reverse=True) + + # 6. 限制总数量（最多10条） + filtered_results = filtered_results[:10] + logger.info( + f"结果处理完成，耗时: {time.time() - process_start_time:.3f}秒，过滤后剩余{len(filtered_results)}条结果" + ) + + # 7. 格式化输出 + if filtered_results: + format_start_time = time.time() + grouped_results = {} + for result in filtered_results: + topic = result["topic"] + if topic not in grouped_results: + grouped_results[topic] = [] + grouped_results[topic].append(result) + + # 按主题组织输出 + for topic, results in grouped_results.items(): + related_info += f"【主题: {topic}】\n" + for _i, result in enumerate(results, 1): + _similarity = result["similarity"] + content = result["content"].strip() + # 调试：为内容添加序号和相似度信息 + # related_info += f"{i}. [{similarity:.2f}] {content}\n" + related_info += f"{content}\n" + related_info += "\n" + + logger.info(f"格式化输出完成，耗时: {time.time() - format_start_time:.3f}秒") + + logger.info(f"知识库检索总耗时: {time.time() - start_time:.3f}秒") + return related_info + + @staticmethod + def get_info_from_db( + query_embedding: list, limit: int = 1, threshold: float = 0.5, return_raw: bool = False + ) -> Union[str, list]: + if not query_embedding: + return "" if not return_raw else [] + # 使用余弦相似度计算 + pipeline = [ + { + "$addFields": { + "dotProduct": { + "$reduce": { + "input": {"$range": [0, {"$size": "$embedding"}]}, + "initialValue": 0, + "in": { + "$add": [ + "$$value", + { + "$multiply": [ + {"$arrayElemAt": ["$embedding", "$$this"]}, + {"$arrayElemAt": [query_embedding, "$$this"]}, + ] + }, + ] + }, + } + }, + "magnitude1": { + "$sqrt": { + "$reduce": { + "input": "$embedding", + "initialValue": 0, + "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}, + } + } + }, + "magnitude2": { + "$sqrt": { + "$reduce": { + "input": query_embedding, + "initialValue": 0, + "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}, + } + } + }, + } + }, + {"$addFields": {"similarity": {"$divide": ["$dotProduct", {"$multiply": ["$magnitude1", "$magnitude2"]}]}}}, + { + "$match": { + "similarity": {"$gte": threshold} # 只保留相似度大于等于阈值的结果 + } + }, + {"$sort": {"similarity": -1}}, + {"$limit": limit}, + {"$project": {"content": 1, "similarity": 1}}, + ] + + results = list(db.knowledges.aggregate(pipeline)) + logger.debug(f"知识库查询结果数量: {len(results)}") + + if not results: + return "" if not return_raw else [] + + if return_raw: + return results + else: + # 返回所有找到的内容，用换行分隔 + return "\n".join(str(result["content"]) for result in results) + + +init_prompt() +prompt_builder = PromptBuilder() diff --git a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py index d149f68b..be1c6628 100644 --- a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py +++ b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py @@ -156,17 +156,17 @@ class ReasoningChat: # 消息加入缓冲池 await message_buffer.start_caching_messages(message) - # logger.info("使用推理聊天模式") - # 创建聊天流 chat = await chat_manager.get_or_create_stream( platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo, ) + message.update_chat_stream(chat) await message.process() + logger.trace(f"消息处理成功: {message.processed_plain_text}") # 过滤词/正则表达式过滤 if self._check_ban_words(message.processed_plain_text, chat, userinfo) or self._check_ban_regex( @@ -174,27 +174,13 @@ class ReasoningChat: ): return - await self.storage.store_message(message, chat) - - # 记忆激活 - with Timer("记忆激活", timing_results): - interested_rate = await HippocampusManager.get_instance().get_activate_from_text( - message.processed_plain_text, fast_retrieval=True - ) - # 查询缓冲器结果，会整合前面跳过的消息，改变processed_plain_text buffer_result = await message_buffer.query_buffer_result(message) - # 处理提及 - is_mentioned, reply_probability = is_mentioned_bot_in_message(message) - - # 意愿管理器：设置当前message信息 - willing_manager.setup(message, chat, is_mentioned, interested_rate) - # 处理缓冲器结果 if not buffer_result: - await willing_manager.bombing_buffer_message_handle(message.message_info.message_id) - willing_manager.delete(message.message_info.message_id) + # await willing_manager.bombing_buffer_message_handle(message.message_info.message_id) + # willing_manager.delete(message.message_info.message_id) f_type = "seglist" if message.message_segment.type != "seglist": f_type = message.message_segment.type @@ -213,6 +199,27 @@ class ReasoningChat: logger.info("触发缓冲，已炸飞消息列") return + try: + await self.storage.store_message(message, chat) + logger.trace(f"存储成功 (通过缓冲后): {message.processed_plain_text}") + except Exception as e: + logger.error(f"存储消息失败: {e}") + logger.error(traceback.format_exc()) + # 存储失败可能仍需考虑是否继续，暂时返回 + return + + is_mentioned, reply_probability = is_mentioned_bot_in_message(message) + # 记忆激活 + with Timer("记忆激活", timing_results): + interested_rate = await HippocampusManager.get_instance().get_activate_from_text( + message.processed_plain_text, fast_retrieval=True + ) + + # 处理提及 + + # 意愿管理器：设置当前message信息 + willing_manager.setup(message, chat, is_mentioned, interested_rate) + # 获取回复概率 is_willing = False if reply_probability != 1: diff --git a/src/plugins/chat_module/reasoning_chat/reasoning_generator.py b/src/plugins/chat_module/reasoning_chat/reasoning_generator.py index dda4e7c7..2f4ba06e 100644 --- a/src/plugins/chat_module/reasoning_chat/reasoning_generator.py +++ b/src/plugins/chat_module/reasoning_chat/reasoning_generator.py @@ -44,7 +44,7 @@ class ResponseGenerator: async def generate_response(self, message: MessageThinking, thinking_id: str) -> Optional[Union[str, List[str]]]: """根据当前模型类型选择对应的生成函数""" # 从global_config中获取模型概率值并选择模型 - if random.random() < global_config.MODEL_R1_PROBABILITY: + if random.random() < global_config.model_reasoning_probability: self.current_model_type = "深深地" current_model = self.model_reasoning else: diff --git a/src/plugins/memory_system/Hippocampus.py b/src/plugins/memory_system/Hippocampus.py index 4b40649d..5ccdec5a 100644 --- a/src/plugins/memory_system/Hippocampus.py +++ b/src/plugins/memory_system/Hippocampus.py @@ -1942,11 +1942,7 @@ class HippocampusManager: return response async def get_memory_from_topic( - self, - valid_keywords: list[str], - max_memory_num: int = 3, - max_memory_length: int = 2, - max_depth: int = 3 + self, valid_keywords: list[str], max_memory_num: int = 3, max_memory_length: int = 2, max_depth: int = 3 ) -> list: """从文本中获取相关记忆的公共接口""" if not self._initialized: From ac7b300326d51424b769cc1f1ddd047558aabae5 Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 18:46:08 +0800 Subject: [PATCH 16/26] Update main.py --- src/main.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main.py b/src/main.py index 05196068..12b81877 100644 --- a/src/main.py +++ b/src/main.py @@ -18,7 +18,7 @@ from .plugins.remote import heartbeat_thread # noqa: F401 from .individuality.individuality import Individuality from .common.server import global_server from .plugins.chat_module.heartFC_chat.interest import InterestManager -from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFC_Controller +from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFCController from .plugins.chat_module.heartFC_chat.reasoning_chat import ReasoningChat logger = get_module_logger("main") @@ -118,9 +118,9 @@ class MainSystem: await interest_manager.start_background_tasks() logger.success("兴趣管理器后台任务启动成功") - # 初始化并独立启动 HeartFC_Chat - HeartFC_Controller() - heartfc_chat_instance = HeartFC_Controller.get_instance() + # 初始化并独立启动 HeartFCController + HeartFCController() + heartfc_chat_instance = HeartFCController.get_instance() if heartfc_chat_instance: await heartfc_chat_instance.start() logger.success("HeartFC_Chat 模块独立启动成功") From 09ff1d9db592d8efc5ebf53b5ca00fb27fc6788d Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 18:46:40 +0800 Subject: [PATCH 17/26] =?UTF-8?q?fix:=E5=B8=8C=E6=9C=9B=E4=B8=8D=E4=BC=9A?= =?UTF-8?q?=E7=88=86=E7=82=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main.py | 1 - .../heartFC_chat/heartFC_controler.py | 17 ++++++++--------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/src/main.py b/src/main.py index 12b81877..99578591 100644 --- a/src/main.py +++ b/src/main.py @@ -19,7 +19,6 @@ from .individuality.individuality import Individuality from .common.server import global_server from .plugins.chat_module.heartFC_chat.interest import InterestManager from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFCController -from .plugins.chat_module.heartFC_chat.reasoning_chat import ReasoningChat logger = get_module_logger("main") diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py index 51b1a05d..4dd49e2d 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py @@ -1,7 +1,6 @@ import traceback from typing import Optional, Dict import asyncio -from asyncio import Lock import threading # 导入 threading from ...moods.moods import MoodManager from ...chat.emoji_manager import emoji_manager @@ -51,8 +50,8 @@ class HeartFCController: # 再次使用类锁保护初始化过程是更严谨的做法。 # 如果确定 __init__ 逻辑本身是幂等的或非关键的，可以省略这里的锁。 # 但为了保持原始逻辑的意图（防止重复初始化），这里保留检查。 - with self.__class__._lock: # 确保初始化逻辑线程安全 - if self._initialized: # 再次检查，防止锁等待期间其他线程已完成初始化 + with self.__class__._lock: # 确保初始化逻辑线程安全 + if self._initialized: # 再次检查，防止锁等待期间其他线程已完成初始化 return logger.info("正在初始化 HeartFCController 单例...") @@ -68,9 +67,9 @@ class HeartFCController: self._interest_monitor_task: Optional[asyncio.Task] = None self.pf_chatting_instances: Dict[str, PFChatting] = {} # _pf_chatting_lock 用于保护 pf_chatting_instances 的异步操作 - self._pf_chatting_lock = asyncio.Lock() # 这个是 asyncio.Lock，用于异步上下文 - self.emoji_manager = emoji_manager # 假设是全局或已初始化的实例 - self.relationship_manager = relationship_manager # 假设是全局或已初始化的实例 + self._pf_chatting_lock = asyncio.Lock() # 这个是 asyncio.Lock，用于异步上下文 + self.emoji_manager = emoji_manager # 假设是全局或已初始化的实例 + self.relationship_manager = relationship_manager # 假设是全局或已初始化的实例 # MessageManager 可能是类本身或单例实例，根据其设计确定 self.MessageManager = MessageManager self._initialized = True @@ -81,14 +80,14 @@ class HeartFCController: """获取 HeartFCController 的单例实例。""" # 如果实例尚未创建，调用构造函数（这将触发 __new__ 和 __init__） if cls._instance is None: - # 在首次调用 get_instance 时创建实例。 - # __new__ 中的锁会确保线程安全。 + # 在首次调用 get_instance 时创建实例。 + # __new__ 中的锁会确保线程安全。 cls() # 添加日志记录，说明实例是在 get_instance 调用时创建的 logger.info("HeartFCController 实例在首次 get_instance 时创建。") elif not cls._initialized: # 实例已创建但可能未初始化完成（理论上不太可能发生，除非 __init__ 异常） - logger.warning("HeartFCController 实例存在但尚未完成初始化。") + logger.warning("HeartFCController 实例存在但尚未完成初始化。") return cls._instance # --- 新增：检查 PFChatting 状态的方法 --- # From 94b1b3c0e6041739bce1aeccf9aee0f2a2635dd0 Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Mon, 21 Apr 2025 18:51:53 +0800 Subject: [PATCH 18/26] =?UTF-8?q?fix=EF=BC=9A=E4=BF=AE=E5=A4=8D=E6=B0=91?= =?UTF-8?q?=E5=91=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/chat_module/heartFC_chat/pf_chatting.py | 2 +- src/plugins/chat_module/heartFC_chat/reasoning_chat.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/plugins/chat_module/heartFC_chat/pf_chatting.py b/src/plugins/chat_module/heartFC_chat/pf_chatting.py index e4486a79..92e3da54 100644 --- a/src/plugins/chat_module/heartFC_chat/pf_chatting.py +++ b/src/plugins/chat_module/heartFC_chat/pf_chatting.py @@ -70,7 +70,7 @@ class PFChatting: Args: chat_id: The identifier for the chat stream (e.g., stream_id). - heartfc_controller_instance: 访问共享资源和方法的主HeartFC_Controller实例。 + heartfc_controller_instance: 访问共享资源和方法的主HeartFCController实例。 """ self.heartfc_controller = heartfc_controller_instance # Store the controller instance self.stream_id: str = chat_id diff --git a/src/plugins/chat_module/heartFC_chat/reasoning_chat.py b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py index 95d3641d..5a9732d9 100644 --- a/src/plugins/chat_module/heartFC_chat/reasoning_chat.py +++ b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py @@ -21,7 +21,7 @@ from src.plugins.person_info.relationship_manager import relationship_manager from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager from src.plugins.utils.timer_calculater import Timer from .interest import InterestManager -from .heartFC_controler import HeartFC_Controller # 导入 HeartFC_Controller +from .heartFC_controler import HeartFCController # 导入 HeartFCController # 定义日志配置 chat_config = LogConfig( @@ -181,9 +181,9 @@ class ReasoningChat: async def _find_interested_message(self, chat: ChatStream) -> None: # 此函数设计为后台任务，轮询指定 chat 的兴趣消息。 # 它通常由外部代码在 chat 流活跃时启动。 - controller = HeartFC_Controller.get_instance() # 获取控制器实例 + controller = HeartFCController.get_instance() # 获取控制器实例 if not controller: - logger.error(f"无法获取 HeartFC_Controller 实例，无法检查 PFChatting 状态。stream: {chat.stream_id}") + logger.error(f"无法获取 HeartFCController 实例，无法检查 PFChatting 状态。stream: {chat.stream_id}") # 在没有控制器的情况下可能需要决定是继续处理还是完全停止？这里暂时假设继续 pass # 或者 return? From ce1247f2fd3ede228a4ff8e759b336f57d0802e9 Mon Sep 17 00:00:00 2001 From: Bakadax Date: Mon, 21 Apr 2025 20:36:38 +0800 Subject: [PATCH 19/26] modified: src/plugins/chat/utils.py --- src/plugins/chat/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index 3e4cfa52..739fc6c7 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -76,7 +76,7 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]: else: if not is_mentioned: # 判断是否被回复 - if re.match("回复[\s\S]*?\((\d+)\)的消息，说：", message.processed_plain_text): + if re.match(f"回复[\s\S]*?\({global_config.BOT_QQ}\)的消息，说：", message.processed_plain_text): is_mentioned = True # 判断内容中是否被提及 From ea1a6401f86742aa78361692aa48171aefdde02c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=A2=A8=E6=A2=93=E6=9F=92?= <1787882683@qq.com> Date: Mon, 21 Apr 2025 22:24:32 +0800 Subject: [PATCH 20/26] 1 --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 26cd30f6..7eca2260 100644 --- a/README.md +++ b/README.md @@ -98,7 +98,7 @@
-

📚 文档

+

📚 文档

### (部分内容可能过时，请注意版本对应) From 5b894f7f598e39abe08092394d1cd3291ee83ed9 Mon Sep 17 00:00:00 2001 From: tcmofashi Date: Tue, 22 Apr 2025 01:27:04 +0800 Subject: [PATCH 21/26] =?UTF-8?q?fix:=20reply=E4=B8=AD=E7=9A=84format=5Fin?= =?UTF-8?q?fo=E4=B8=BA=E7=A9=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/chat/message.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/plugins/chat/message.py b/src/plugins/chat/message.py index 87380e7c..b7afa817 100644 --- a/src/plugins/chat/message.py +++ b/src/plugins/chat/message.py @@ -309,10 +309,7 @@ class MessageSending(MessageProcessBase): def set_reply(self, reply: Optional["MessageRecv"] = None) -> None: """设置回复消息""" - if ( - self.message_info.format_info.accept_format is not None - and "reply" in self.message_info.format_info.accept_format - ): + if self.message_info.format_info is not None and "reply" in self.message_info.format_info.accept_format: if reply: self.reply = reply if self.reply: From 55254549beffe8ccdb8a5ab401cec188e54fb480 Mon Sep 17 00:00:00 2001 From: SengokuCola <1026294844@qq.com> Date: Tue, 22 Apr 2025 02:01:52 +0800 Subject: [PATCH 22/26] =?UTF-8?q?feat=EF=BC=9A=E6=88=90=E5=8A=9F=E8=9E=8D?= =?UTF-8?q?=E5=90=88reasoning=E5=92=8CHFC=EF=BC=8C=E7=94=B1=E4=B8=BB?= =?UTF-8?q?=E5=BF=83=E6=B5=81=E7=BB=9F=E4=B8=80=E8=B0=83=E6=8E=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/MaiBot0.6roadmap.md | 16 + src/config/config.py | 2 +- src/heart_flow/L{QA$T9C4`IVQEAB3WZYFXL.jpg | Bin 60448 -> 0 bytes src/heart_flow/README.md | 14 +- src/heart_flow/SKG`8J~]3I~E8WEB%Y85I`M.jpg | Bin 93248 -> 0 bytes src/heart_flow/Update.md | 11 + src/heart_flow/ZX65~ALHC_7{Q9FKE$X}TQC.jpg | Bin 90138 -> 0 bytes src/heart_flow/heartflow.py | 429 ++++++++++----- src/heart_flow/sub_heartflow.py | 206 ++++++- src/main.py | 6 - src/plugins/chat/bot.py | 1 - .../heartFC_chat/heartFC_controler.py | 94 ++-- .../heartFC_chat/heartFC_processor.py | 45 +- .../chat_module/heartFC_chat/interest.py | 503 ------------------ .../chat_module/heartFC_chat/pf_chatting.py | 2 +- .../heartFC_chat/reasoning_chat.py | 153 +++--- .../reasoning_chat/reasoning_chat.py | 1 - src/plugins/person_info/person_info.py | 6 +- .../person_info/relationship_manager.py | 4 +- 19 files changed, 708 insertions(+), 785 deletions(-) create mode 100644 src/MaiBot0.6roadmap.md delete mode 100644 src/heart_flow/L{QA$T9C4`IVQEAB3WZYFXL.jpg delete mode 100644 src/heart_flow/SKG`8J~]3I~E8WEB%Y85I`M.jpg create mode 100644 src/heart_flow/Update.md delete mode 100644 src/heart_flow/ZX65~ALHC_7{Q9FKE$X}TQC.jpg delete mode 100644 src/plugins/chat_module/heartFC_chat/interest.py diff --git a/src/MaiBot0.6roadmap.md b/src/MaiBot0.6roadmap.md new file mode 100644 index 00000000..54774197 --- /dev/null +++ b/src/MaiBot0.6roadmap.md @@ -0,0 +1,16 @@ +MaiCore/MaiBot 0.6路线图 draft + +0.6.3：解决0.6.x版本核心问题，改进功能 +主要功能加入 +LPMM全面替代旧知识库 +采用新的HFC回复模式，取代旧心流 +合并推理模式和心流模式，根据麦麦自己决策回复模式 +提供新的表情包系统 + +0.6.4：提升用户体验，交互优化 +加入webui +提供麦麦 API +修复prompt建构的各种问题 +修复各种bug +调整代码文件结构，重构部分落后设计 + diff --git a/src/config/config.py b/src/config/config.py index 83e47837..bf184a00 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -28,7 +28,7 @@ logger = get_module_logger("config", config=config_config) # 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码 is_test = True mai_version_main = "0.6.3" -mai_version_fix = "snapshot-2" +mai_version_fix = "snapshot-3" if mai_version_fix: if is_test: diff --git a/src/heart_flow/L{QA$T9C4`IVQEAB3WZYFXL.jpg b/src/heart_flow/L{QA$T9C4`IVQEAB3WZYFXL.jpg deleted file mode 100644 index 186b34de2c8115074978456317fd795e4e5f2ac3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 60448 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 t2KxJ7o!@A%9I$jiu`OI8{sz9VgVg{4 diff --git a/src/heart_flow/README.md b/src/heart_flow/README.md index 5e442d8f..9b392a94 100644 --- a/src/heart_flow/README.md +++ b/src/heart_flow/README.md @@ -79,4 +79,16 @@ await heartflow.heartflow_start_working() 1. 子心流会在长时间不活跃后自动清理 2. 需要合理配置更新间隔以平衡性能和响应速度 -3. 观察系统会限制消息处理数量以避免过载 \ No newline at end of file +3. 观察系统会限制消息处理数量以避免过载 + + +更新： +把聊天控制移动到心流下吧 +首先心流要根据日程以及当前状况判定总体状态MaiStateInfo + +然后根据每个子心流的运行情况，给子心流分配聊天资源（ChatStateInfo：ABSENT CHAT 或者 FOCUS） + +子心流负责根据状态进行执行 + +1.将interest.py进行拆分，class InterestChatting 将会在 sub_heartflow中声明，每个sub_heartflow都会所属一个InterestChatting +class InterestManager 将会在heartflow中声明，成为heartflow的一个组件，伴随heartflow产生 diff --git a/src/heart_flow/SKG`8J~]3I~E8WEB%Y85I`M.jpg b/src/heart_flow/SKG`8J~]3I~E8WEB%Y85I`M.jpg deleted file mode 100644 index dc86382f7685e111c164dbedb1d5704d41afb987..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 93248 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 z zg!aFG(+33zz#^*pllo-S#$2#av>3q@`@8CSO)Y9pVjY#C>?vGW+mjBOlyt;PKNJTC z*`igumH?l2Vm}m6fB7Od}=r&+P7qZ&@li zK)EnMjbhW(-B=?m^f!9>ykSUgiAe{8k(jIg8(;^D&WeFTkY5R}Rlh-J=GCWx1s%UMaLu67eh2(1XkW@z<+vRh; z36xl9!*Ezrnq#J{7c%)=^(_h1Wl0bSAP(#1vig?V;6K>n4A>w9 z4ThFITa4z&#~5}(3`XH} zKi{rm(WD@}xxE2JuGx=8O>Wu`nS@dtqQL+88z2t*|9Y@DU@ko~lK)y}jwoQ6sL2)f z|6`dp-qy4XB4S*1GV_u-D$zswL}WV2&(;d z9~cMPt7j`@Pb(XL6iR*hWV z;_@#r*79xbGC=^vyot-vJbBZK4F-Rat?=d2NHgg@as{-r*QHs~TrS#A;Qb(L& zA9Ayx9>U5%ZPQ%MpcwKsFN_#p;B%w77$t>lQg8i?1cB#9owOT^E4;g(nMDk6E>Pqb zJ5kJS-NKNvCy+p-d@l;cBIAt{Kc!M!kPnQAw5)eFR zVdwrI-<_adbuOJAC84X$kk7j~6a^lqi5Jkcplv;`rlH59_zO5XU`Flxaxto_6<8pu z!%aN!Fb}k)&nH!*vtUsAx;Of0rKC{6lRud?ofK~!_>;;*ZA;y^s97-DB@?36NQ(b& zykJJ=p{&INu+{pY@x?r4H1__n_Z%HRHIP796yY7PJI6CVUU5GpRSjao^9-<$bQx*h zUc%1R!2xDjklO2Y&MOq0^Y*W!QPx-yUxT5l1Sh)Jmp|QaKkx`fKo{Jv$Njw=@nn*x z@|h)1o=XyLU$W0^R)HRi067r_A{`i~kVd=fum=!5Y$n$@bp61oQLs zWI+f%g8=A2&jC(;PJmVR0MVyb7PJox{OQ>?%`a$~XO9uw4gTmt!G5k!TGT*qi1?NJ z+?P5NFQgbFBJxq<+j5c#Yz1)T8j~H$FG=D{JO`3^#o|m7eQ_&zo@=fSnFLiaLJC!G zW7^cg9{PxlksX=;3)po&KHsR+!C}>fhf8z40UVWmW(&Xy1gfPU-HcTve(xZ%nPG&6 zKT4sxUH1#8Xu~*52dhTpV>Zj_R{tM=SFnyZ*xwmJI!~nYf zBsC(EJODF7if~Yqynj>`bKU@9ne+`1$~nM<|HTv}V*a#BR4#pc=)ZpH^w+nek8J+y z+y4Xt=f8pA%4)hsqUUN)Nh_=H!rq+#v`CU(SFZGNUp4%rzpg|n>g5mSC`r@K_>eXj zjEpL&c^p(GMU_ZgxI*tOFV%(2-W^LBSlJvk03E$=_C2>{Qx*RDX2cN&MX29*gHS7Qg}*0_?YJ$*etb9t%I@yhRFY_jB12pT+gBk}lqzV50H%L> zL-PSA`03b4=6>OH_&9$TOuG56hUldGqj_Wud`Lq1+%1e_H=>nv9BEE;P`037MQC(l zK&XcZyPcQSLZWWeiZ5@jBVU(o;jdDI0sZQ@MiI_j&@@IaY?oX@oV_2Yu;#;_60zn(mxZ4ex zj&w1;VArCayPor^F;;rO07I01NP>vz-Np9i!$LDZ)^GLy#@qL#5RT@V2vWSy@@30= z1qGrgJSLYrgEs`8q03?!R>yZAn<^Ow=R zIln*L#h}qku|Kl9vWgYwy#+?*L5bjVnWw*S|2AE4y1OmWSO*Yx&ykd*lH>439O$kO zCcSndXpl5Al%Qk+d;Gy6(>xjBEvd=@Xc&Dn8MrAch0y_bCP0pLKb$^N6{|p@uxJ!mFpZ4ak{s{TRpI| zf`19A(S4hpfzaqHZ~lD+`0QxaF;$9w-*z85@AU+``U>P7y8COaYgKw|frqpG2o90rJ8o=s4EzQM$NTV+v zIX?)iU}FLS?=TrGW%$)$k0I1(8l6Y!61AO;@$kq;8!Q(-u{WmQ-)rT?qngRB! zITgiDpj5J8;OC>*z)LB5v(qbM_Xq*{8{>pY!3X-J;p}f?!+;t^bV(NC@Tvq z<7vi*_c&V5;v#sRPsR6KQ-xf4*d!R!ggHd6Ifj=|6HB53@fkEWWC+SN@ z@%G}z9lS>wC5AapXrC6eJ4RAu9fJ2a{)tCrSVar8FLKa3T8oeX~3zW zVZKwP>h64fXBKDl&9Z&XbpTB=?jG1KSaV&}WBBdFvj6(>>y_A{2fWy1Q`(|sysN-E zS@kWF1Ta8oDtMi@(p0#<4bhX&mY^EWS}fHXO%P-QJGXw%CkB2`yCh*ta!hQe1BKW8 zS0fbB(b0sfk&J_726lC0Q!~rOV+%DhC2*Ly0WmQ#Z``6EnTx@peMPq(E{&(;a(B3W zSd?m9_Uqh5pXYwEhNcKWE}A#IehEzRnKMD9>fh!!)I=s1e^}5Al15X{J*)-_oIiDQ zZNDv3D}t~-otXwoh z9_!fDL8qX0aYG5!R8$x*1c!qd=#1Fw(2z<93;Ub!qK<(Wl*Mk2!l`a<{u8KXc8)W( zp8~BMkL#qe&a^NHZa&wW!v^c{MkzhMUoF}3L5AvX^bdo77pZ&7+I zFXu~ZmlfL9G60LD{2LhBs&Jn?puF;-E{?; zq_LndR?B*znciS>R7Onsad4KCGUPh$7o!WJuNUYdVG-H42JQA`ksNT#o2tUu3;K6>3_RGOgjk=F2UY_pqav)9M#0S60VQI;kEbOgiDfL-K5EC98j^xqmF&G{A^Rg&uMj;aK7wfXKk4Sqs*UhceeMShgtt zz||8;3<%%I8Lt6WUIHZGz(4Loc;=_T_P`6)7~`L#k{pTBbikH~`CFDc*p2@T3%*>o z?8aoW8pDj|4pM9M-MZ4~!S`y+{wIerpb%;iKk!XcHxGr+f%?{hGi~;eVRf#GeOTXc z3S=Ndl40M)a0%T4oa7q5ezcl?Fa_-HN+>}t##a-9BkgES7L%HA82m#Y zNO_=^etvM;8v)wNwbcXE_j_y@24=t< znUD)%AYw^O6@syaLQobvogb|HIYXAWtqS6@HuxQYJDF4b*K#RC7jn!(&LP%;-_^x< z0y}eFpMHi|e~3tds|GH7QWojoFR!S6SpVfaOg%|iD4#Xt=jlCY)RWlH$aJ#jMYvd$ zW`BP{$N#&kNHtK1Gu+cb7MJy%>vYu(teQ`s3~OzsSlw^(Gn~xGa1~b7d^i!j$MW>X zMxBx>SL5NP<>}9fUw^Po)_mrws(y`dHD*B1>RSFeXp=}{KsEIiLSlf!KLW^&4QU`v zB4@+^Y7lQDl3rqME5y7kb7y1l5?V&^Z{a1>Tbm7}e&O(Y?BW!?4aVIAk8<3$gbPLz z{g4vnikS2ftpCmeWDunlP7H=ZD8_hV*1J>NVHG97f(9xdr~O`b)#c=vUGP)eGAW3t z!|Bz0S}BIcqkO}OKe@DygY@l2N6;Z~V)u${8XBG2oUP8jTc*dvOe7T{#$;)&c3T?V z-j6KPYlmK1taY^Eu@{>IDlJS^w#S0sDA?0L(a#4QNNp5}=^qOy5_?gsNq)?*WZirT z4VZgq^W4Nij17_i@->tDHa+@%zKiAS*tv-)P3RwKS-h@v*7^({XyAx1-lk|>QPG;1 zbc!GEDOLJffTGBlaSTsr1aCfiZ3WZ2fj+)8?=Pn<@}6;EISzD8{vt&gV4z!e@>ox& zJ=&^dreDkT@zV!Ifj4Q>#t^8SYf0JmBbEv@(SRW(|Nvxy`njA%@_%0{xt_(FcP7w3>&4{g<1%^I?$QqV@VH5VS z_QES|P?@y7qM4^T#B)bDXXr4@Q>e$TxC>U!jb$QK7@xw*L1xv0vj@{ezeN_HzWgp- zlk#&}5>V;|J3APeCRIK8n2(Td=j(x0MzuGwc|j*5F7z!=0hd+7x*Su7Xf_c;J#yT? zbae8a`Ggu1&$gQCW1Ub8qK2JQX^uay&KFXAqI zs`)!z7JZums7&HA)IZ)c`Ql;3pDplfDPtgCtO)HO+3Vhlb!%*OQgE`40E2UdR}}rF zO#Chv<*<@K@_L8f~l~Uji71|Oisy5RWXs^Q# zd~M%NPT0X`2%&$pK0erw^wmq)?+&z^jEaV3N99IzzOp;bpe^;!`2pO2q1+QLh!`yU zzEvY}5^o~O5(*Y*0BgU~xCF~@2BIr!D41g=+*-#db!ITuEU-^xs43gNU!QGVX|M~i z%PapG+E;cx)l)2AkL@ILwc!90(X|OcJ(v z5dgOhPxG~^m+c;(ogRT4B<%&97x8@aMs$YZ>a<#YQgaoJ`9G6( z9l$zf{h~$_iR`05-{45X_Gyo!$J3vQ;yZQJ$16Trx;s~h#LPY7sHUs?W zp<}Z}vOKp-8?2HfUibT{f0oTj6tSFF?I)7r5!o31znNI|S5lm??>Y&0x8)d%Bj?0- zrt5z=3yy~Z(;>Ss%S&NvrP`_#pQp^^SSC)bxcD%#Zd-Ljk_1O(>c_WN7jIfL+ghu+ z7o1wc1byn`U`J9MPm0ce>?rlQB|#?--SXS0*;F$lmr6xTTJTTRw@Me>gR<6|Li>tU zMOFP6on6=7dyw$R-N8@rRC_+?>4_j#MXYa1m+-Ggihfqp91eSgB^_8D-9{(CtUT*6wfxe)8Hg}pb0UmvZOF^&B zkgXatpWObrR?O%K81!^Yi+FZBL)K;botyR6+;GH!pV}MEbItALpjgXa%})!iEB_~H z6q&uG->gpS(6>1*|9m#&<`=i9B$abI4%t22+gGFcYjr;TBU*4(w=HrL5k>=A|L{CR z?MJbtn1;EfT8dI-fB)p zgw|3K(DA;zp7Mz4)f2~BAc$3(*j4*5%o6xK7AD)#l*4d|rp zyP&j=-Xc5uS^_9amkK8NGH0aE9nytaN8-ALXL`!dBpG%T`5W>3hIL%%E#%}Cb#O}w zh?l7cHk)(_0PADDkBs|X=94nR1n?6)wa}r!&-cQTE|k6T=Gz_aM(&k}QYZ3UGBLEj z0i~`Fq4M7?X?T(WGW)w%C){#rN;IZ z*=j01mte(7??t@_XdoZfzV52A;>?;$!mC29hRJoVq!1rE%H`-~ti|X0Fzh~FnDrbf zdX+PLX+giB^fulXs_B??Qk`n@!aLE|;xV7VrS!HP{&3!*==AZ77rkz2-7OTDLcZbo zj9AIgA)!0hM%djjLt6jUnQ<39!*h;avf-`cqfZEv=gzMT=*QJmh+o}Dsa7m^B%)2dOa&Msr~ z#PsXNVy=d}uAk}<4si(UIJ?dcYM))lU4z;hhMf9b`BmXP)nWeK7^v&RZNmMaM58vw zzEs&I`wrd_WRBiW)q@=iuy^yagk>b9<l#gMCgCM|v&5Q?npon=7y(vRGr4BONgxmrPCC z0nJs?RLjMJ6^s8yn3^>Dqw{=~(Ifpoztpdn15uMddMhO6#O|&mNiN@@Ic@1q`^;Fdd9&5-RiExiYNU?NxN-AR zPCfpMV7$O@ascEQ-5P_QW*UM~WY^_Ruvj5h{hy1yA$jMnh}X_lXhvrTS24=uxo?85 z?c9I5c1uL_RYg^QKYXA~n8&S$3Sk`^G=8iqaW$J4_1E6XVR-s0Z;F7V?>9UIfA!|s z&s$(gVm;WW5Z5u+Y^tmy!86ucXPz4SFMuBElDI)i>8ymidMW~i?jO_HR8?7 zn!$QP$fuiRiilOaDdJ^|!8XGOiUvzhiv2^|>wdH9CPdH4@Hy71l!_HP&MoWhY*o)3!TB^l->CI)U9_8zePzC^ zoPRdbni)q0t2o8e0{Z^nNzzM%q;BB)i=XmGEpsZ1JXxA~&3*s|S(>HB5=px9`+YiU zXh)qv&t-sNu8x|t*Pfr#|LOMUQ^ij9r67CPZ@R(|drNOWp5gLOtW)MA`fk$?DF1mf z!*{b?&l_~CG-&4Rys?^I@~qkiw1?(Wsz4yr1F70d<;y;gh!jE#m`p5bo=(;0$5@qz zno4cP82*{7G$((O735=*<4PDY&#Jkz_;qfZY z8j!RkcYU`h--4;=Co>0>#gvmZl9eBi{+|8uw}4*xSE93x$na`Pa=tI>d-J!tq>}X0 zkj+(}?_HJyPD@$sFkfLz_0Pa;cD1#bn*NZ%2C*QrG`bsZPBduk8D2#ey8+0yw^qF^ z(u0v;mg$$rb;w#)3-rXqh*k)fmh2|W8&)iIbw?{wr`4%9|1m`YQ?>TN6;79V@y%CX zRZ&Aez{3)#N482MDuB!9@9*`0y~nZk>`u&Mc_zhGfbmQ+^_<+Mjnb4=W~EgHZCh@j zh*nvB#6=YqBiVi!n;BIj0b}Y+>w4+8eThrSzVmViitq8|{%cnNr@4h5CzcU8asj76 zIdbHpIM&|yqn0A;m`Z=wYkLBu>ObxX|Me&-0()uaw#njH7x*Y)M_=Op>V}Bo$(kMX zmbBym?_&yYu8hPS@Km_0Kt-v>ZUAyDkZJOxT1mwECVZ44KTg0%%3csQQ*AhF9Yr85 z@vQS=JK1@>JE=@hQn7~s$RE5cz;u^#3UUW)LyLR1t}PH6a*??s`;08h*gqG?<~?j< zfy9*hkC^R;>%^aBW|zI?I0vK(zU1|vpX=*$`X^+~_!nA{bBOG>PKS#m=E9eKQD z7sVvK)R-K+lOxWU5RjNN2sx$9+@6$6^L(|VMrFzT z_Hx;E2NHi;jh9Z2i9Ab@5_cSIZpz`s0{CQ8W+u)1O^)g<;TZZ7?uGz?DV%k3O{TCp zGqQhUdjmxLoCfVxR1>oZf+iH!eS7J**SopuL;8$>a=%sljNZktzQ1U2Yr@$!YDbz~ zb=({}DGoGNBju23@aOY&7R~4hj_a1zR_e^uvg|wcr((HiH?A-!ef)!F&L<&e@GJOsDd%gE>16Q$cq-`USwp#hs^ct9*@JeBMX%O_p0T1E}Pd*f@ znrzX%YA1>&-s9A);mbfRQ4PT6MmOoSN{_=tiV!p z27(cBe+O9p8a^D+Zg%dG68u?~rZ02;K{Yn0K;th{!LN&h=c8=V)6-BKZH*4*`F;}dz>rkIF61aT!N$L8($QdVs8{d0IL>r$MwnNR>R++79@9> zKf_=rQ0;qNcAU@ZPPjJWt58fd$aMk5%**3`+-Opk zS9ViNpgiT&N-Dbdyn)J!Cesv;jmzj!ocwXTK)mlRR@J!{W@%yJu29c$IK53Q=i11E$+tB5@vVsfe@QruZVoA$#-&Ff#W>jh5dsf6pV7R9+keLi_Flo>r)zic z3mOb5)oJn$irlIP5|;Kdp{#r0&_MsnaO3ub(k?idyE(B?QH8>UFcjykJA-=UNB zs}t}}ZR(Twt%>*+KnRnB?01CA0hWIRt5+T4xdC~+ zco*GIXCNhHM@f_7U3vI(48PZlCwELQei z@fu1Cj__{cILRampZHuC$bbCQ7b_^_!(sjI*T*-Ra^#YtC zX2=@`-KuZ>O|~l>bpMi(=8T_J6wS zx8jDd8>pq$q~{MsFBjFFzR#Bh3cerZ4=FRqe_CLms8QoeLHW-XiYaFW-d%0Q!wd@k zT(-X(O3Yr9?)_Yw5mu>{V%%I!Cy|DS*v%8?Ri?kNUlrnlW{0M++Z1gz-ZqELA79ye zB?Q|z?QNw9mS(z1PKv^0G0gG3`#}~8kA>#2Txv&*zpbrw<0X=9s7X|;0wi2XP#R$k zX@xePa`w-7c>iL|B)%k`&S!M*U<)#NWVTn9Vr!4>0r zT|zZ|U6Jcf5C{U!G@j^3;S1&cG?ANK{LtqSMW8Vonx@fQ?JtoQBaoRk>?4}bx`U5C z`_ejvFu`k3S(Gw+%-s%_1tfv7#EH|4c!nvVTve-yGQdL&t5w zSjf(DfZ7zQW)%ADEeO(+w3DRTOm5zs{l^|Az-lc#>4&92cAO9}F8EyHS(AI8zT{*z zICirFNQQ;Z0v^@YWj6iT|B|E_0=D%4T*QZqgSiBCxtt1uHs7t zLH3&u&^~yoyOO^!lghQ%Fyw_4T99=c=#uV;Y>t2DhCGzApK(mNgBARmSBXZsA~eRW zp&tjS;m{i1CtcyCjc2_vERLV$(BzBW9szXV?u=e*m`n$BYxyhnv@|y1DPHIY&nj=x-DJo?r1GyK;Y!{@Et3`Fk@rV7d0Mf z-5E6}C8z0ZD2aLc4{$44Jnm}I=)i^mnvmdXP~o9XxeN*>!|#RsRFiX3nU8|J6aR1$ zLGzLetc87Db6=IKlCP(j6Iw+)IN!otvyC`tUFUh7K&-61!dWF*1b z(2H-o*{8j{c*bvqtf@4VrAkh$R@+-4jucGs&JlcXdMG@2ZHAHV{1!yD>gxO$ywHm? z0b0JcRYwue6rObcY`u}Z9WauAtS8QLMX zjD2erzJ0ngK0x;_Xv$#Sb1>YJaGaFlT`;bK=91@Qza_`X77_Wd&K>{*Vu!J$z87bX zQlL%qo6KcMq#|qdEC+(qzdOlg#x?TIE=2YQuWX}<=ze^6xU=q!b)3IVRHFjo#5-QagYR<*-kH<_-h)>vgY0Nd^QiK_!zKz2c%Ia%|Ye_HjR?CMzjr%7>q#fhsbNe2N1!3VM$UI;DG90+0p&N9C&jw**J! zE{E8AhdJsA{8_qb=pKz4%`z$NJ4sVSRlMd<)TklbT!mnJK_0W?b4L7{*@cDS^X{b; zl}4mc-W@#3NmoeK-hhGi$$ge~9fIl@JZYmEIUSL=L)0cZx1#y+6aqNqf`sDWl8niqO-i^7$m&5+CLDrc%I|@6 z#$h;(CzUPm5yfD{ZT@cqK*P_5s2;N;8Ng(8NU;Oj^ zMlY4WJkvaOszQ7bTEb{AEiz!oL}XIi7Uz^ut=ZO`X$@5=@MPue?LyS?NsEmuxsdyR ztF9EzzDoQH4%cicRq{O)8ScM8*xcNT315zA1*o8zv2>gz%17W7hLbM$LiAmv17vhk z+Xtcci32z1+NmwN@%6#JL=SR_L=PX$tQX-BtK8TLH@1ZJs|D*`qudKFvjJN!yQu%( zMJtK3^*@&oR#+a~1^(<+Xa*A0z(3-Y+^OoCY-x4@7kUJ2^5D7D7w7`6Q} z6;JgAx7*bJ&lIF`$9IBKr#kQ$QhUQ2h~5H-fMR?3=SKp}7tImn78mH;Z$rNR7|3_Z z@`|K`!MO3!NI;@G|KP~@A6}x5ssOJVZ87&{I8nE9ibKUtnmjUdJ>{^SgIg_=mF$;y z#*^_^Q%Es?vIfpE?y50WQhBNrU!kFgyhda^)T6h&7HF$U<Qv-qr;cknq9Rmztst5ePV3`mIWmhA2{9W1&T z)lGjjyW;Wo$L{wp`5_)#(j1Vh@|_#-Tk4k&i)NRhG@;aLXb4Lxybb4+P)C1P5Vt zb>#N;#aS}`(~jjYT}$G z?Q3p?`k>Hda-A@*(FU5zPJ9VRJM|v_EFx|H*ITHq*rvpw2X)ULSr6;sRdf^dzV z)M1|7=o=-u%f`I<_xG6{B6;+xLP}m=x6Mm;+I^$g8~c=B?Bn95`jE6i$0EPDzSz&D z@}f$1-=^`m^Q9s``TXGYezUV5tvB4IkfM;&{xBB^L~_~R#%PC4QK<(LG!v&)Vfn{5 zSM61Yi}^EuH!RRF{`Ow*f3*PTw>r>NO;+jVu|+82!%=x&emq*y*6qu%-z42D&YbQp zw`#eVxE(bjFN^w#QtWz)@H_98rD+#TLiMzP1^?7x+-)S>@a=p0Pc5FqAKY7?uS~gp z$>R0*%^Xcs+Kf1Yf-?74c_EZOvZkh3tm15jXJsyWd zo=MXyhV;0}HNqP~TmLKL$6@xm$eV!>G{2GA$76a6%FedpP4x8xZm30$$?wt0(I~s6 z)cmyE-6WZ&M(Nz{(~qB}`rK=x#Y4JXWPXMkIm!=z$?b$ZvCjMccf#iH>>AkypWu#{ zKje}z$UBz07Zl&Rjld^~@;p2ImTXm#(||gBAiKUGZUVk};}|6hxQU$`mqO&dv*ygS zMEE zaH7;%%oGOG#xtU&5(%xj)X^a@t66h}E>d2~nxtEO$8A|&OP6V{<^~sBG}ZxYN5E2(BQ?Kx z?iWv6h`;0s_Aw8hrRXJV-_|M6AWfgVjlSncXHLF?cZk{A+8T7&i2K zObf(N1CL66l~aOJ#NU(T>z`$7+Pb=-`PMdgPK97~J2#Px?5>gR-$x3lqkE+_IW+M2 zy}H_v$J9Y5q!Y2rhedYL`6G=HQx6K5bWS;UvpDrvgUjR{9G{mv-PQM}E>MYFdIh+? zRb9P^p&|+nLXzj%QW6(E*p1qCjl&E;;WZ61e}e%{=v~FZ!YHjWJNlGjDWFulzBG5F zHE|53_Lx*gmL@r8-FGv&oKS|LCdb>{*xfj8tnAg~S8evUPWm}Coc%;QpW?YwA2fY5 z;Ytgu1)QAh(hCt){l`^WV-`{aP0BNQLqQ*uaYcH`+BCIk1uT)ZQgF)VN;Lue8Z?s9 zLuLBs5dW9$>vT1rBO@7sTlj|=t0v%qf72=x1Y#KVE?8DRva>u`i~48Eib@_JU}>id zMdL}GH0O|Q!@J+HJ2*{71Q?7Te)`bFI%jD1z>UK7fwZeL$#a2vzC%(sCKvssygGSy zE@Rv==2VcTYO0#~i?rVex|4iBLxUMMqt>s-t>R;e}Fh<_B`^I@ef6=Uge}_Di z($&ZHb!WxnS)DI$%q1PwU;OFIR8EsU81Y4+^V3G2%`besw>Dc~BFon-&{^IN704O{I&o6F!2cHxqV2z z)|N5l-6PID@fmc_lPkJ+pxvTroQSbDpSYAL0;h*w=hW|>#?SP&&_f6(oYJ@rzRN$$ zRkN~UY<`;j85S=vEpt!@FaeB-u^&AC!P!x8wWI;didCbJ!cLKOZ~cf6PbXW%KMXd+ zn&ABOSZ=GSCd^N%Z(Ft~TQTP<>0k-b3eXPT(8Rc{qlN#zV5FJ#!%V$ zA}=4&3%)l;qIdhh6;~G01~>SMw4c6fF-nm(MY*2efzgo$J}lFtq5J;ztF5n(2Ek{o zI)=0_8JOR6IF}5>kg@S zsgE6v1`k7Evlm;@2D1dH*~z#if9zB-McIlx;@?$LJhrsYAf9?*WX44H1~_4`qT z*q)T^C+-YVp+7(m;=ZGz0I8w*>5?UV^YdR_?jQ|g^w#?_nJ5FYZmiD)LHBDR10i{NAu`P7}Yr@O&pOOZYkz{>-YuM)2BE45{J&hD^Mt236UfD7=EFqfO7AxB)|YA zHpf$wkW5Mm%D-#F@NtpM3%u8M((v>P^+|bK*N+L-;fm}|x$j+`o9F#ogo0CD*2HlU z`Z{|yHTMUY+b0~K_2rD}NhD2K++&d*olK2hQ$!Ro^*}_xvMxn%5Reb;0h2T%MX+31 z#EJU#>4Z?XDCEEz%D_0u{YT3e; zswWGllcmY0#ub{cp(YitV!II0YIVU52YQFYwP#I)Lztkhke1!Vf; z06Os9@3kM7!`?N|dmYdm*K4meE(AJ-9Q_`yWuvuNB`D9JgX`KPUz%^!kdC2x5+dXp^MQ&eAOe3kAZl5wo)r0V9hZALa|(u-zy z0M&$q$h}_leYb1p3R#l!^60(ZCBNo&;iUG`>e|h5&1On`q#F?-Kqgm{ARY}~= zpoPcGdkq0zMdd`s+}Ltdk!X$$5f)%_gf7EqOLux!93o$J==Jsr1+-iAQhS}jrYm}` zoU&E{IrkzDwYcat#+jwof?8}+>LdSa9QlFKMJyw0Hp5E2NDGfcW`#r4R(ccrX0GsW zOBVB%x(X8h5zfopCf}C8X#L~o!G#v5`7MZP@bD{)EwccvR^agZDVSY1BA+t!V1-r| zslD){Y6y$^d$yXZ&plR^Z{KeH+EoZF9a{;EueY;y85Ju_YSi2+O3;kuUPP`TTVMPc z%RMn2@#K`x_ptEp$6`X1tnWZs{JQkAh3$XG>s!n9?m^Vg=j1kcciI+I+}6xSeu=s7S*h_j~QFiSl}9jWa4w~9Ax zZ*InN7jys+eAGcF2pCh(GygHDwWN6;8kSk6M&q-SCf@)vWZLsD(@tJ8*&+HC$0gvjwe#hF_!0UuL{nYsAfDAHJiR^=Bz%*gaT&OMy&w}Ayb*1;r4gnZ+@8R9T9PSm^arEk2ma#@Tc z(Gt`*FR%an+K3?SO5{KdoDT!TM-LGFXFc_`fUYI;2CxsO9NLe(dcdJY6%hw^%SZx* zz5JrV8O@;kAQuMP8Q!xzuVMP#Hq%&;woe#Mmn)J>+0B@H!;!Hy@yO@`HV9?R079IC zL@p+dXfYGtw>^L%yv=Jlxfp(*DvYHeqm8Ue#RNpDl$+;L>M(_xV{C1pIzKQ%;SjQg z$$7lv==PeG-QUiN{`1iMAX{H(^RtXa?iV`!pNCYrW_sLFckG@Wi*8zF)2Z92K;^x^ z#s4T($Q?`NJkgqC|GPC5k1v@tg&f%iw5b8zcb*^n_072TrW+;n9{zI=mj@CO6qO1(>H?*p+Kan`SB6G}lk#(id--g6 zpndd*;j>pzXGYQvWGNMlC^N3n2S`$YGmD@4Svg~PA0WF%8@uaj>`!dhL?3P+?C!Mn zZ3*E}UeYM@kAN&Zpfv4p1USpB+5{FASFIDN`lk_!+7{ zn_#v70mI}i6NU#?x1O+&Vxa%P~-IYy@s7POXSR=y{T@JBi>y`sN#tB8>5odKFh?vq5i}i+PhB$@1uS zm9@AjWNegT+LX3A1#YtEiK@eW9GFDVX2Ooz2`{k2cJP0n3s3WurDN0+fdPMy7N%`e z#v8+XtY!Dmc4P-(9s;u$ID!vpFg`34H5ffH1$HBW#aoYXe&{7J32A-q3}d>f4HWiBrSr-?}_}rIsoIYl;jBB-0~%?+8Ff)B&D}blm|-1 zv8kKjhYa45H#S>d_BS^;LOX)46vWq6XE;vhNlS6KH4f2Ga_gthr6)dB-eM>0{Y>OD zJv~rrLo%F#RyIpjp7eC*OYtRpSZ$^w>Ulq-<6cE78DZ9A1r5K|3JzS|*1cq|Om#Ww zrz+|FNfJNX^KZVM%kNO#n*S`5OdB$#UX;`M=)=TB-rtJMoUof;L&ji6qg;T?#M%Gm z@}@UjX*yRY=5oLEat@Y^_s#Y&(-NdwTDbJ9-XyD%oG4jVtpKY0_pR#8a>890&u;vD zG4aSxi#zsFe{@+&B#Y-c7Qg>z>!DIi=@R^n=oZkmKk?s;oTR45;UF)|x<1>p0h|9-C=j@WDg zynWB%l8IBGAbSlY@`uWN1^mdqojl4CRl8qIz*G0yYnN}LL_NMro#W4~pQf23^J*w< zs3GMJz7YgTWTbtCcFc;kQok+K|EhL1yx`Zt^#LI)>As!FAn|?!C_i@z1=XOcHG=EJ z>6C1CrAg^dWhUr<^Q7;-3g~w$XO$CMj-{NkU;>+QNPm4}xaVReL;qL1SEvqBDAgaJ zBSypHAPN}aLcLd8KpmX&z&dkJIJabeR`fr4_;#35%@o)6{q!9U2}+IZVW;uZtg;${ z?h%Wcf!~R5*jGwVcM}_;Ck2R^q>{@GdKa9fs6{+1c#B{`L9!$Nyn;U{{66#n>=-i` zUuuMe9COLy#PBz4Mlr&KMd<0vGc&>R$53bWz?yZJV57^V?A?5e@-fc6|Ko4UbR5zI zR>{cy(O$9fBGv2@sKVuCYU!+){M!MF8v?Xz2J#oC&h{yqPO_YwpR7FI#uTSQM4^jb z;V(+3`Xg|^Bqgy}rN`a69GAKMIK|HBpmpP*3v)5zb)g4^i6K^Cgwit)UT*W}K<1A2 zhIu?@2B@+aXGH}PztJO9YYXWMd$6}?pX7LnM;SL|UN_%x;sO-HBVqYR)OiVdWh`-< z=@B+md*z<~^kQat4JpC{8OkIGa*n5G5Bce52tR8v^-la^AUyGZsaZYU#XHk;OyiX5 z{C%}Ekjt3r187W(@TdsFPK9%mX(sNIl6tkG2tFDauS^34qmT0Ut-eI=!r;`omtH(@ z%!sKyf91xv;nn02y$$_WuBIj?bKkpvd=Dh4Fz?cFBs#MFX)8v~szk&Ulm?HP2j?;$ zHOifXmGUgIW}K|9PQv{)}^u{N-|IGD@yghvOQ_^-~UL}}m z1c$#wm@3q029mSiUsqptY%=!G%)LGyA_Ng(K=-sPksYZ+)P){>1}JkD>!`W&`|T~F`dhma@q z-N35VvzNNIBk_6qN7yD8(?yntPGuK6=9GIWf1cyNArv@G#M`FpbE8Z2LzJ(qs;E;r@a01pMCK!{ zyw&!FZEeM;!Z}b;xN})V4dSq06!(UoR%*ICD>D>lhRy7n=R`UcEsmZz3gXG3jkCm-&& zzzG=L$HWts1d{KoQXo2Qqb9_41=iV|)ryo1Z79lDgmc*T_jQxgK&q_x@(Gc4w-Egw z4u{Zr*?auJ7bVN#Te#^Dot|m zR?A`%(NM5a6Fik3M#9VQOe^)h>MhcZNY&15;dky0PbF=S60zE^%hw(QxeVDJ4OAL} z<7o!b#VcC4L7-Wbm6a_QPK*C)iE~#@i_3b9obMc>mMk(U$a_W%=9Fa3NJTE$N7kmz zpPI=i7(`i_-c3a>f_fpo!E|r~hsh2BihOY`t~*Vd$~lgQ*)$*6mpKZR9Rn4nN}k_` z(rFmUC?{>N7$~42O;o}lC7nWK z!S(*pc=m@M%Di+SQjbm5#DvIB!6!1y3z5m-8@#Y#jVW9w9OPLG3F{N^cx*Qr680er zDe|5WizoT(oPpwl$MZc(Uv(?EJA}vv?RrY_D6B94=hutw{Yn*vzXLx+XaB+6q~@5K zb)E{+e!{v9b}jo|Y?Z&@@_VP4%EnJvOEiCD10`3t7H+c*tFJS-@DiAd!i10J)cfrKFRido)@bo68Bf~ChYxA-Sd+D>-xDHxvFuwAQ5-^KT|Cm( zF=pTsYz6m*|`4 z!+1Klg57%)gjo7tuM_SmXp|Mlm#IwjC~YjAa|VPNrcRi5H7e2VZ_nXjgX@IjZoef2 zvrb%(+3`q*o9s_*C1I~ds-iKZnBeCt(+H2()=P&!Bd{n^BX0b-oJFrCOd`9KhHdV% zPMw~r`*2a>G#$Nu)IX8_uxwkmVm|z#XiBmu`UqIQ+reHr_35_oVk)lUd!zmh9U-p% z?0nk}nxjrLejM0J=(J>s5^;~jCAb^Tx;wUQPA0}ljAw{}HIq3-ha#f0gEmk{5yOI? z2fQGgjS3z^64Z+<%EfpQ!l)t$hzy}Q6rHw2^heNYeR_>}shh5ZehMK``>@zh6||>r zMREl48e5xwGZTxbC~)7_I2-!Z3*UN`VX(}?D2~m}wybO4)|7UpOeP5#H+JqgDXb(g z*AFG+@D9el3??`Z&m_@U_IxS^P8j$Q7As5>3mtXpZ)6Fl`5q?8`^yRB=p!aXkBUDxBlxVcRXv$bO{T zHwYYj@K68?3)hnvDMj)D?d0Nq<{*XaiDW8rBVJUH}IO5lN?^Hfe>n3P@LRW>{& z(#{nLi?2YCP3lg1@)32guorX2pt7>pMv0ts0$~V! zYN*vFM#q&u$`XQ|6du^S){kXX^MN%>GijS~5bHG}-7}YhbGu2bSO8TL@g4H`pQ>dM zdBO5dxy1l-jooH|bzJT*2o|Y9EDbCAbbH z=pfRn$R!mJ?R+}!j$(2TaM{!4N?1Zk>{VbJR8*x}76jinsAxgd5IT#>U$?MI`}I1g zghO*hx)Yq2T9jUSs-vgHIkm6al(@3=Vp1WrFFDx~wVIiS5tbDZD4MboyGeIF=95qE z{eUunB?MPH609Tyh)&gOYdz~Eb|P{=LK~|;O))^XIIE3ref)E@SzT5PbJDTG5xL%#TP#Y2%@XXY|N&;|)g{xwA6encITK_cwVk(BzVi{)5J{=p*EHU z(1Gm7Gs*0f-n-@$v*AMa=!_|lUNYShARM!VYO$yDq2H*kY!K#J4Wvs;oyBv$?_3i^ zc81+gmDyE+y^ii(C9sd`at=eEj=H0u9b0c6e-?M$D2ba24V#!2pNhkK+^ojcoxU?s=1Zi*QNH=-$009xhP<+qAAF>gJ`K4iWn%=?#;vKUs?Kd zUTO`QJpP|-SFJl?q7u1ExD&C@WNw(RCNL@gLK$%7!t_fysKQvWjtgyxw!HhTXGlYi zBZ^=JK!=l?oBN}4kJ*L1d$wTeG=2VmVw-g0l>&b1b*}uc79dy8Hrk2aM;}P_m=q|V ze-7Yw^(n_TtZo}#x^*y85ENPp!$NOpvv5_1 zj-D=c*QCtIW=hC=-d^xY00@}m8O&vK z&j>f!w8AT7mLSj{QnKTwC`H4W^8U$-qP1ax#U@?zYfKp2F}0ZJp=4XH%&*pm@3-c3 zZ@%*QB!X&Disj1YW{dVP5}rjP(LMvmcf_Bu#~|m!qed9=>t8m1V31vl=@YjfCQ9b; ztPkCEjUT)(q=k_SOL*Hg!zS|baMCk3s12RrS5T`aIE>U(cN*rEW zuSCZW$-KMdcMF{r;n^|2(VgBDAEPP-sjH2b6==|ONwBwryc%R!4=rHTPssU(ZBvp` z+$1=w(-C(t%bJ8FqlE~t{U3KFjdIUTk-mYnB1*~zYI&$JmZD_r2CeHe)b0;r$N(?8 zbWVhA8CSxaN+I>m9o9#JnU}W;{w?t*UPIKP5wK6hnv2-TyklNYWhe)M6MrT@Ak=@D-^1QNJI5?}8I|HrBI zL$*M({ZVTl{uDvpug!``{@L$k^jc6*vU2 zjk3V>)}0lg!Akecx-0GgM!MKK%T4dYgR|0 z0gOa{(Z-)gAZbd7m&sqoXX{X#JO8|S)y&k=apuZCNj_>_Ua*h<^*wMGXff{Wrq$gp za=KV4J(QU#iMV4_>@$P3H@A_&zyo^+d@8R}Yz9B(ijL+hrdWCtMDAGV=d}29k@vnz z%hRttZpJc_jpmOTs?Qd~p?ua!_7SJEqK@S2+FJHIiGNo3jXs|JuMH)peSiK9KYMHQ)Ds^&2YuTp%*610bXwg0a9-Bz{QNC6 z@ED8{feO(lzmQ!7qk#GX9y~2f#bRg0qzro_rDf%EZ7xD=P6YF6wK?pE;PGWBtn`1q zLtXlZC!EaY)7e`s%}DwRx_W z@PWtdKOBw+lR5%~3{sbl$5Cv9M%!+wY8ygc@f74Vag9EUypCG;o)E}Z0M0DhkuoAW z;X8SySS8z!7+p3$io35$Ny~L_6By(C=YP|p126S$(9uQ0ts_OYS?Z!}uVhH5zw4u( zC#|2_!}fuBdz2uGTS zOC8$pC8wopgs}2657H%t@ zWI4zc^XTC%jSRMg06fz#VLwvFr}`c9MQ<+FB!qIMxCWr&ZqD*Yy#kKk-w2cJ`C6>4MKBHD#b=59MnLsAX0Y zIr)?KgUa=Y?#ZN^e3SAW8qi2;@*kgY>nA5H4!_Vo<@74xIZ7~tE?}sDYsMCeery!%_u@MQnR-oHd-$!!zm&5Cr z#fMumYw?pyfq0-`6fT{Vyq6bGP@ZtTU-f<^P1o#u<|*yH!zYOn$T! zNe>sB0)bi{f$B&#D^<6VLF`1-Sj4ZSBjFv*=_fOyb-j-26+lR1Z=qkIREHHNDWV2Y z#O-RwT2*GwI;t!TDCbtqgmxG5jW|)X7#DcWHQjRNcbh29tE zlq_vqk{2r=2SWbyIxrt@;xHn}QYL=wQuD!+CTSGx#s`-t6EdVoZ-|BtHgj;A_&`$u--*o1KG-LYlwEqm`x_6kY1WAD9Zc2+jody}j( zGm5f9)bBohpXd2K&);779PZC`U)TG3kDj5UNw7x+W+t6J@#TPf0J0o}!QH+1(kqWs z(Lh}s6vqPpZ!99NxZ-zio(fMRp5w@6s8D&y+wN|%)V^1h&dKv1Fic79_S=`_9r?t@eh*Cwa@owM$9`v){^_c%ZckfH)}@5 zcR%T-v=Pgg!fpK7Hr21C+W<_QiO(Kr#$sc?M(QX>H}%GhAZ?fL0#+IHB6yv30o6}m zN#^ihen~NRCEYj@@Fe9_1=`_<@q7q^VPtUPS_{^BIj=zTqR(QigXi8^e;fNpc zjr7BHcz%2`fetGLqLOhUnj6mS@%lgg({5J+E0jDVy|^gA9+BW(|I0EEwm_W0W!3`} zH0`w-XcMsx=sEt93Y*XAcE14K3b-1O2xs*uGZ@AyU0rB3KG1aP)HzGq272n~@I$T2 zZRh8&a_>_u@_xjl#|}9O0VmDHW&yj0Bi)1{Ei1})e;NgF z+P~O{?+NYa4xsAbl|6W(^|{pyjp&opf4Us(V8`c+s6FBNl!ITZ2h6feP87H{lJ#}$ zB@tGJVDbnA-Xm+*C8UWL?|Ednev~A#Hc$TX{M0F1C1Jnj+}aH`t&bjbGXWcdyPbxS zCnbFVH=}xJKA8#2MJD~}$(cSo#}P`R>g1Z=->mh0dvX>lYiHi4aPa#V24Vq_3}w=S}DZ_@K`~(ha#kwP*#{YhX0egfJo4jh$+?r z+cj(8P}zf=TRZ`^TfWf@&PsfV_Pj)^=&9b2dL@}8t0D_{txMe$Zc;Nxy&LAL(ogz4geLph=BG zsG3}6nd=yijg-0RxNTbt zb)0zpRoIM0rFK~g;eJSmr!AHcm8mS2 z{A=BM_rH36iP~mn-W7&!*|1Yh9$WSO44=+=C}&q&%plD@09dAJA%YwhRF{N=j(;km z);GV&90X5ZyratHUZ6O7n%PI+k-z!o{Sb-K^7c7RgUh6?H2ACU3@LVaRJf(mD#FzQ zGV}fR$oZE(`|iZ?kJfcXjcxZq)QU&9Ed)!IlKrDNm49NyNYcpolofv#^e;$#k|s4+ z>}4fJsNnd9J(-9e=nu#nfXy;C97!@_eF-kq?0afSg8ErrP3^<*-mueN(C`&;d)V8- zdXiJOeprC4%kCjB7VR*7TBFWImHAzz103y75JFX1Q?9lHqRVG z{|z9iXehuZH$3|mlH%JVemY24NkI0JZSNKTy4!$to8^aHSyGch84YLWW56tcOKTE! zJoN+3+cxts6c?Xs=Gk|4%HtC4#s4g}nNjBOXJtDM^c}|NA)5mUbBU;BqrCM}a9dEi z|DbL7?NbG00=HyNC&s;KT?3mmxU+^bis1W}7J@7uOAZc%90@!XgcLc?IXWgYor@C% z*ea1EQE0ta8_E9*xGgnpmUi6ib@&0uT2Ti|cDe3yGC7rHWoXibKV5UPIJ+-2Q3#20 zW`Kp(mpDxgr{dKfuncBKVUaA%W_gXr=7Nil&pcpeCXV%w3gceA3->j6WTyf`X@n?Y zzZ{ZML(VV3)=5`S4`V3VEZ4NZnD*7R$8@a>nf)x?`R6w-iIyCGOgMsv z39Lh)EWn1OizpafL`d$mkz@A1{HTSXa&Ns>d^}67P%qP&tHgn924P``s}w_QJ^CXN zO{M8iIQc%CEs=q-T0l-QAl57ZGLV7U&qtO&G--nt!0Kbtk1Na-EZ9XWzPB9iVKQ~k zDSH{DM#rSR%hqP0fh-ykHMEtq{Wm=Y3FVh4OK3G2Rn2NsQYKy+le|6MgAd%FR~T>R z4u_*5_cyv*Nt!J3g9jx(8_ZSTz&z;(^x?U{rFi~c>H3%6hg)J7xt7g{tbU&zx_Cj9 zCM-i>QCLAM*}$6N2JIq{)MUEPsLW(PKD^s}HGRYCh5p6(>vEj(839|1X6XPk z@vHjfP=ya>JwLH$zB4euWe*X-Bms*k&QgIAg%S%m&D~`%XoeqJJG*Si29gqg&d@$ZmP05q|-HDX|!RqK}<6 z1fj|%{V6wpSkrtlH_4{M#)nAFDBl@MDianSfPq60AUD{nj`~(dp9Y{7OnD}7g&b73 zj?IvVZug8qT7$l*J`b~jd=1fuFcX1Sju>0f`E4&|E@&X${QbRgy2IkunUpiIf@u}b zvkCpgEFsC5lBts%A*c{<^}Buz-mHl977#S*kWicdGvgBlo6;1z=lCP%>vC|T)Fe>> z#R#Bo5P3e8W&8^G$KT)W$94e}12)PtXH+EdtIgN7X^LN+iJ%oc7ck2nV^Kdxv$q97 z=fAuiSS1!#!~VS~mGU4MNb_B>*dz@`EiXTR{9`^=3mn9{6oGCa%-sme*>*GCIzS%- zQ+2~*3esA2O1=DKR-hWdASoC1&k#N`1`h(KsmY%(??NJ znMh552>W?x)rmr7DwXAA=cdm9zwZJDf$lxH?z??Yw*ko|4TQl)_A~wgzAzTWTk3qi zC*}){K2|fmcA>NyH8KxvKE;VP!qW*4#sDFTq^#I19h)p!qXV`Noy-vc?#hW3-)<;Z zNp({Z*(5Z>RR1fQBu#0BHX=U@rC~+Q^s;6F!Ret}bK=KN+q>HY<2Srl!6$Sz?sG5z z-)27CeybjP@uB9j*zHhw<414u(x;f;{>WL(p*Fy&>WqvYB$Jqw@+@FyD+r?i8NY2y zl(`yUA^myt=e$6w;rA$A!V&O|#`*O7=La*qN)Do`RfJD6n8FcZQN)!?(Zr4!CO&?5 zry~ez50%eyaL{UZs%Kva8dILvJU{~chlurzJ;oTiooW-b&A?o)XX5=)3|bRi`L8x( zfEipQ=)jqr<|zO@V&4MI5M?XurK$g6S(^%?;gJVp7LYRqE?Y$6D|!G}En!Wnfa3$O zYjAGcig>LXKx_=ggIhtA$3cY&FM~XY--JHmH&3?*@B?s*rZoA5c&`A$g+K)ALV6xL zvxjjRx1D6!heYrm{(taR5OlT`QZY=pMAwir zz~w!D^691L|BY5E*WM1HjL-bdE2^|&ouVqY$CEC#eFyUykwks`~-e7e?a?;m3@)~yt)`Ft5LxtCGmmuPi3fp`Le5PxOvsu9D+godUp z5Vh5EZ0UoCSCt&g?oiTi;a5+;U(IakBMv((#4T|nhabs6j8ioRoeEVtxM)b~5Huk7 zoaBJ#x=o1|sgfZ-7qvmjes-x1Y`_Em`RC@SHYgNkFl)=azA`J)bS6w6`A@V;hx`AHR*BY( zdg##yQU!psLS3xX;uPLb4$f*|qo82`4VjDyRlX!>O>n@7S?)v9<&>?Nfs)8xx?~M* zYG$1LfK~kkGaL;Hip*rO_9(Yx7=JVT-@*PG9W?CBsyD^5@voiv*FPja1qGG?r!5&I zo&6^(jVRbdR)X|!T*q_#B?JX18CHPxz}YZ`s~bH%t{*DR=K2Un%QCbgApGkGP}qP6 z(iJ#6Q8RR>)q)ShuM1=vSW`0*)JWF$YV}7XEmUe3^mQ!w%x*ST7!USOoPfxn`dyE| zMP+Ksd$90{ypO%`RI{}f#?6t_fF-A=vz66hUf=`N=^I^iof`}co|WK=JOItJahEU5 zXC5%sBZ_)Q^4h4vI(K;8R~!&WV0n&=?DY|^78VsJ1K9;o|2&3p)|-FKs8es0R9F;4!E}W z6Mq?P+>%r=iJ_427<*c-O%yB!m+)C!u{_T@-96E6p*h|8$jRam!jK5p z2|xRHbSajd-b!8qJ|vX(142vP|HiXz95@0aAdf4}v8_)xfEF>;iqRR&_1%4h>eK8j zO~O1)%+G6VYW4snBSS+3>MNEKz)nFy(LfqH2vE~cFg9Rg{u=PTLCO1T_fuuFgt<}t zOCK}4>4AR`(^euqgm=#5r;d9!0kWh4A018c_m2D*D87Yt(H#ogwco=P+(Q0nK%Q!J zeb&*?!y;3VNTl&C{2pB0SP#8<)A^!Y>oEUNWoGU$OZ&}r*td=^uRc`$2t5Dxv6?Q? zM9hfsN9RqP}1k0FKYQP@O2N9HEgDKpAs(auNYs2Dy03tdx|U zm4lH-q@JA}9k<{gDI*tg4YCVl?V|YyUo6%50U8fLQ2ju{uV(;6njP23%Qsl~c|F{d z+r?nFH4@Sn43lNJlAmvKz@fz(W*{NhwxV~=j35T=Dh*eBxpw_r31CI%_m3ZhHl=E`Ak zqq!?QrEY_#Kc})C-5pDrdsWxAjlI_;T@9DTjg_r=UhYWnD9io^yTN``X7U%laaZW> z!x^L--O{<8YsC?>SNK2ZjIRPB8MSq_=W$_j>65 z&-Ml@7^bW5pAx7q4!PqRIP!eAqsa75Hlw7i+s6P+7+BX&g15#zD(XIISBEB|#{{yo zyY~QBFo-VKLOPux{sK6wsVfb~Q83Xr{z@Fo$gGb1O8xhGWDeMwZiSQ98NMH%POGMj zeGa0tZBny1@XagoUgNnwd-iBFi*-5Fp<3mnYx2eOn$wIfGdxX$~-UpOT)B7 zE!4f4f|CZw9{MFF$$2{0w;ggAUa*HCK$nD{KTlL5$Y~lL{FKTi+LBII%Z|Hv zdSRLLuHCuWky7*z0O9*^5h9hVAD@N$T<`$;m41^*G_j6YbeX$WwM$9RBB3ZbYc9|@LnMaU z0kl7x%h|r0OwT8_ettJv&qaq8t7>YT3ym@G%>wYP*YbIVI!jVrF(HRZ>g%0%FDIg5-_lSh%NJgxDl9y#UB;D#d0W+sHeQ=OBE{%hpsf21Q3*pD``kBl$c(-06Q2rBuF#o z*{H`b7!6}u^$(l8lMs@a&3Pv#dNLaf*nKXSs3;b^`0H2o; z`6pkI@}lsSfudt@V8Z@Sg0B||Z2kTMYiFlO>vQ&}q@ms1vKHQOooV6@sh0f8i< zNQMc#{KnjPH{wVoUBml!F}TKm+86v$QctCGuTUD-9=cu--D9^FF0{Iu6$v${Te3K2 z7`42%u$6Wd1a6ul=9?glf-$-ebYq-XNUtR3vQYC?P}9t1;0n9OJS=4(Z3)B0XlEqh zxsof)M{1OzMPPeOCLowBhhFp1SBkH(Hk~rhG@OZ1sK|qzIt4;SF*3ZLZgUL>2QFQf59V!HMdJ2FJ(yM#B^fFfHIs5|ZNz+HDIfdV`oQfda&L|_ciR7+K1Q}`QV+hEhJm1dA+LVZW?talx3j8x6)i)Y1xMx;5)apJ@$v1 zHQ~WAH}_P|8T*#1C|tXeHoiU=zvm@NfyRva9l;S0ji5)_Xwk^-NIp%^0N5bH-0{yw zIRCtRbN@nxyPuM{lRYH5dJf~wHV^*iwP_0_PyJdeNk}A91AFG+Tr&mPW%%i&zyAvbBsN4EmqmLyn^_jcRn}UBiwz1 zBMQ1XUAg8f+!nCQW1;>lw2&)kcA~?~OBbjimdBpiK4WyWQDRDb=Ig~|HK}w&;#u$h zgMkDgX%RK^Z#0d(53OaG6UkFn>i3ymJl=T_ZQ@4Mf`fX;{_V-rr=ixXJmW-J9H*H+0be@#V;izbRq*xDv z-(G9P;>sXjgy|^Tg`(;fJ2*ZTQ8UgCe(U+55aDAMe!ig)_2=DUFi@S z2n+dc&I%|8N=rY0;j?Ecb}>BN0ZQ3nmmc~na(O-GshXK`7qmD&?gAY5BjoL!APqhZ zOzS70IFEP1R9{6cdnc@62*=*hU`_BoDNqWge&!+y2ER9*F$o-DB^FUAG@gJvP0}DP zJFQ}wU3)zihe9pjiqpMJ2ziM&_qezcq7l;cx>)CgojQiGM->Q4^6iL-X~QKt=n5Ch zy{P+eb_?8wDb;@x_5u81orWt*GT`US8CgQeSK`3pG)B<^z7nt$D*3FcD#e+rB7`A8 zy#3n|9@U$VO`akqpdE>gTtHK}$XI|AW?6!UydJzVy5zC(r4nfT`*=vHpZ zTUuvnZ=Djrg6P)@t<6~|oBQ_2L3XzRfo~xp*IM#QeCy;uDMhYsjeb&I-sg8_AAC}k z8C9=C!LX`0t>F+JB-M+IT*faHR1&?49L)9Mjvz%k8aF@Y`4j$y2759yqt;qM{C6fk zpM_7xo_OEniuDI0Ozv?n30Y9=xU62ajC})2%~(4lj|AxH7Q|D9dyaEeMp{Q5lNnWl zCa0i<8v@LCOBm!+36!x@-WzL`hG&F|c04GX%T_O~D5bJ=Qm~cy+MZNgv@g;o8H)Zs z+u_`x;UT&fLEl^cr%DfXiCdv|oqgLL;AWg?jA5B==a8^{?08|*M#8Q?%elrw zmAGr10r={dhlJ=86_1b6I43L*c?=1w+CyS)qm?3M+0%RObLcnGBUAKLc`^q_0wz`3aqVOP@-8SX8(_8xkq450CP41#Szp}FPQGJs+|E89t zmG!PhsH?=#w{&#AGLBZhGDC+)vgb-1KYw+t$;M>QC#A|CwwKM=7GD?gE0X(j6E9@G zr;tK2!W8<_-$hH8rmLI!#q@y^t#zqwwd+iiozhn|Mci!~&f+pTR=EOEe+C8y5~=A{ zi*_>mLu^%~#Ib69@^3W83+*2;%dYPsQj?~eh)-Q#+H%1-HQ9yi7lGqfMkgypy_B7l zZ0w;~(7NrIb)sRjOYTrf?ZR}QAbSk5rc$}HsZ2K;*!tKgczN+ZU|c_0~$j`8)E@HbgnVqKlR1Z+nhrN&0ay^oO-H@)^{$T>DKCHx?; z?(sK1o4=aph@mO?-b2rP-mheV#i&nQLkB>4nuXkPAr4wTAT==s%TH*5d z)$znwqeUH{s(?1f$$;6tT-#Wu#DvE^sT?glVzIT$KY)uDRf4%-e(`LGShr$L^|wsZ z+I!Yw+5jL&3(0y!!C&}Ah=;_CWjoZf##tjn+P1$d`ul^`c@KJlx@5-=iAvTACuou0 z0@oM;p^cafEspY2lCoKEpHf=e;m0E1^NN09*mfSg_u0Pg?`=zrjVRm_x9Daao<6zA zNZTPZs&oWB9vo4xHw)ipjH)(O*Qf646*n(t707+|HHQc567}q*MPz&#ofD7Se(Upx z=>9uPj_LKOiTvSNN58Q}`K59}6lpbIUfXz7w>!PeHaw zF&|>;B3XEN@B!wNSJ?8mGXrdO`GF7koHa-6gbS#lPoI2~9wnc56k%?x8dm zN=LkX)))WK^xziG>2Ftym>B{*A}AJVWe^1cMEmGMmp*rAIlLVB``9R|&9Oxn?y42X zUt?Y6oK%;_&0E@`(fU5@oyL2ioySt&-Tf0RFleMFq^b+G`8x`&(BzwaA+6hz3vd;9 z+E8-Vg^@zrqu^!UvQm*QUpTa43iEMHTD>i^ib0#~cN7fUuX=k$7APh03F-`1`_y%l zR&tcn_A%W9a6Z~CsXLvtzL3XDO}vjjHx$qID2$9d>E!o}zA&DL=DoJzfeLeEdChvH z=tt9jvB@wo{6%Y&W0)}-GjTA;!OdMd`LTRB1UqKH?EBSiUYB4sU0+CEcQR~XiZ))m z?u-ZpI~al(W3>9@F*hGM3o&(FmCO3kZ6*dGuu$)H zc%|&ec*mOt&g=o=eUFhv9h9`A?bf-h>8s_FNWvy#izyKfvNNA~d^W15{H|(&=7G-j zE=O*ki_^7ys(+YKx5&Pq>o$nJK4EmhqUr$+e73BjN*m#a=LWNjul4wr9JB_eg)R2^ zU+1}8og{uTWE-LJEVQzIqKf}_fs9R9FNVIv+ButVPCLZt*MhcRoGy=i&gbzoj<-(6 z%)@CHG-Tory~?V*F`Pe-Nw4dg=+r?DW-+}8@Um`5pH4PsLEhoS>~t{4=@&pF8B^t) zzRuEHzLp)b8e}gqZzn#d?USS(MYDT3>v_HX%d2pRXUx_aThB_g&U&tPSyRc<%f}^~ zU{>#5O3&FGuDdW!TKe?er5;8driT4EGeL99u3!vxL(lpkV_;_A=wAVyX;woM;#)Vz zb0#$^zDi#=2?~O%?^0RJlRUcC(V@OmJKsYYVQi30;yOtC8fJS%>oMb>wPIs_z9?IUEw%KB)mmyFHr>%Z6Uv0cVxLrl{QJH#O z%*IduknlMs{D=3Ft9!H8@{mS25%s%&Cwe~$i&MkRY zssFh#OKssB(;g{N9LM5h0>p%O>4o1;zsVHd(q}QnVhxJiBDAXhvf;lqW?sjuAE7l( z?6s@P0_kd#1o>R+_Ur7ayQw;94P;3fBbYTypIb>^S2PIhJ{ZQ?qOn3AEnx4~Xlc&oJexA%LJwdwR+Zu{fZ^G45v23@( zr3_<(jIQ#h?^yMD&>k46&hZ%{C3%y!My*l~*gQI}q7i?ily783@$*Gz>2#wEYKj`! zw(f7pzLja!l5JXJii_qwVD5I4d^SvP4PYhdt5?Ly!^?AcznP_q6o+PTvt<;8T|}bt zkWiKJTZl4Y(AT5nXZbN*5|TTmx4nZkK}-JMA5=%?3BPQClRHx$u4^vr(i^4-Zfb%t zGglEVG{Gq*clND4gOEL^wMb}3@g#I0nNBGQnXOJ#f$l>tBnaA02xbnYZ0Im$+J1z9 z^oFD9VT@MQSV@zIH+h1ALHX{Mg-T{}7lcu#cADX~UoJ(kNUe$hW`Pwt=H{`mE|1xQ+W z4ZO?WyjTC&oss$Cy**Epd=by#s^-F(n~>&3-ZLK?PwALrtqr4R#&~Rniv9$b6cfLd zX3+BkvU}{SpCi>melb3vc|!f#Wxvo!pmo^|4OV>KWTr`?)qPGEcosDAaaL=C@-_1N zJAuceR9Q;wZczzIHT-@;%!mOm_lojM0+FmIT3OE;WKQJG0J$zC80%s@i?Z$+C*tp5x zR{u*!U&8*zjYlKLKR$N~Pgu&!slVUPfnWakycT{P8Y=ZZ?it45Am$-Moh(1d31aEY zS}AAufuR{|SPxcHi8AuWMtq$tgxDNanCDFTydWeTkYMIV?YX})Lh;H%$quz74SOa< z($uIRD1cvU%%`D!v?&~#3xf|q;ob3eZZ<}H4IMg|&0HwHl!PYrX{$uH6488>ke3_< zB+r)_2zCH(BGpmzsKKL2Db3MG>fTd^M!fR|mf`3R;&hoL0;($8jtf>sbG_DB4PW!t zm!hZRe3#R)Fe*_K%q5S*GWvt?OnTxpp-Ya994>*1`b>6I%K$t0N_w;P!~HP`U0n#g zpwrsZip-<&FwpdjQoIM052p7MGQw7Z>=^S5t5&I3;o;#GZ#A&jIDUg%SJk>}_91`B zvya54IIx+#YR0NYslov$nDlUkFT{v*7dGyE$bJJDQb(JJMaB=CMg&j~5FyA!UX*V# za4<$zvX3>W4HWoXQ*vnNTQ_)_2JO_7nHkM*o#9(d?c9v`oFCJqdR;M@-;cS{&ClIf z5Qk2Ax%s_iYD5v`~1qJJ3 zgonpK&_FXf*?C|(H{;ua%X*y{kD&|ce8fj4by4|a?>Z+>QFUFK9q%3tx zGJ7+^KSeI);IdEb`1$#_3lLc|U!(+1-J8A0PIWb+Fk_@`<>e;D8|{psI%jnA$pet$ zl_De;5HjG?GvrF7_Yct08nkZFdUgRQ8DBvME#kENG*SSLA=`Gjxf=3*Ozd3iSscLK z#nrO7zXAiiGYL5if)h8u&^CM$@WeC(AMT5K767>y>|(Q&IRX(N9RRyFeRJ=`+;TYEBBXaU-zIQ>z1@~nQ7{Sss#6*V?C*02**j~y-Tpi0N$?mJR)G-l#3iCx(0 z(GwBt5wfR1Vr&llXn7pIern8c8?tszwrf&iLlu$Oq}lNYMs}iwUnNk6Z0>wn0@|cM zmXe(E4Gm#*s%gIR{$yZc@;S$~M+mH7UQQ)z{08eD=a*@xfVS29l0vV^8k49f0nj=l z4pp6gVA`146y?;Jbo!i_<3pC%s-okiXr}Ph9ksIY%=a4K0H(&dXRbuRF~c@T>w5p= zDX_6y3rDVKjTyGZet4;v!kE=+8*=afl!hk1oajN|2`qas0oLEb#Caq0OcV!T;aHSf z0!kJKQpGR6JC7)1 zT>x9srwCVr->s-{9i-(Q_ak8w1`9kFIh7Ii##>~BTOLWeJG>h$n0%)D?nqhBhnHZi zFDmX5Ua9q#ab9uV8Tc*fX=-`^z-Rb#sAC1>AQQa7l~(bu{1vA1x#LN@0cSv~P?+}38oyfCjfw+Y6WCrEy4&Mkg ziX*^as{wfLT+`_0oD8TOQ^tZeT!ziehIys?O&j@fr?aa5GcLlrN7gN9o6nA0ETESf zBpTTUG-{iS`9*dxlGl$k5~*)5tM*>{txFDEH@%LC7%2+9ks8u;zBx6E5!wgLq6p&g9wypM)8G4??@i5aYpEVF zmwM)>_(+VpyKIv*1m54`_ePB>X6A{g?+D68*gyRE@#A0+obgXIF`Li2yF7|{N17}S zNiBQHUeGdNfgp;0gJ~4<(Qo_yU&*{zYs-?;q63*$Hri@jLDWf+0pK~j|if# zOjQ0sxbxNQ&l#yyLrFuHl?CHu_H?6sO86dc>~&V5f(C4h7|SkEnA@^J<>_y)#(hCL z%7?@giBXbcUz#0Kj3o+@mE#RqThOvwJ^KF(V^3Z|VC+!J>gqIu@7@^H(T}4Ddd!?j6UAY#61c~1egoKC%z+dA%VdS@8U8<<>>IoL`x7dL zWF>H7-eDN7!8X}FBJLg3bcT9Jw3Sk5+K$36u=)A3@%O%fU6|W&Pyjz(nnZcVRu4EU z->z-^@d5lWf(Pe-9m9K`lD|oc`NQ97p8l+JOocL}H*;mZ-QD-Us4HAulvOD9f4Qv#q8nNr#6d><24NZ;h=<3o?+> z#h+NrJPAl`2N6;+e8LfbfUA1Sin7w$FAvFU;Ym zH6FyKA9vqQfz=LW+Q8T#$?-xOjk<#t$#1(5U2seFoF7Xc_8p8!Nd?4OzaN{xTEgl- z8@fw(l{FMeq#-@z8ef=P z^T7$tjw80#lk%G-_I5SaaKs&m_Gs^pE-6^e-7%U_4d5F{CG%>UX zneZX*z9a7=A(R1am3qt`r9_Pksonxi^A}rQI_cGdvN4{t1a<@?%j@gLx!!`ayj)yd zr?^_59*DmM>wEk~#{Q?f}Tjv z;>e$xBe804i*lKEk>T;HrnaIQ?EOq8CG%w0b?5 zPmMtVE^5{W4$SGn4ZD25^5+F&?q10qjDr15uZYT8TsL~cN_MS#1?@RZI*2~G*4S6H z|GoY6A;5#zgEFLo5gYjfZQ`*&1d%v)us)>spnrZIM57P>U}~v6-xA*nBfM5Hk8`vC z16GP2g{TzuKzsRs{m~KADj>{MP){X%EULcZkUFG&id@cZJhVa(PB6xb^U!bFcei%6=7n@8t3J(9RMCFbtBIIP@;q~Ewr|566- ztABVM;|3l4GlGt`RDz|{4o0vTS{Ki1DncV1SUxXK17=1vsp0SFk_t9dZY;0^u$i~_ z5j2?1Jt?~f1V|xI(zORM`0TBx4qH5-kz5;3_zTaf?*UV%pBkR>#XaKd?^}=qclh$d zZerdVBWct}v2T8U1fM4|GQV1oYzFg&!XE5v+Bo@jxL$wT4(Xq)8C z=MHah(}+G%bN`i?8qxjgm+eQa=RPX(zKsYT9AMl$LfM|5X6AXMUg&Xxe7_1H&!>a>5QAiCZ@FN` zBN7+KO55j`@BaUtDW^E)cUJSljh46o(nDS2e)3U9Z*ySa*CmjTGOY?KKM9bZD^td1`F@O2xEYnxed6pZ zV6*gZAUIG!y}&i?C|HLd8eJrxq!fM4Xu?H!?d@)18OEGVC>PQNAK%19%&L?tD2yHlUaCz6)sF+@;ry3yhNI3jB?ov=CHq)Bh>EZ^tw;@RCx1CGV`47+@@8U>u zFSyjU4|M0J_L2un@RK+hK=LJ&2s_~8yrb}a z*5`XaMjD*_)hJ00r>}k{{J*&XA`h-#a9P^qP2~Ta4I7VETBRLkK95gd;g|dJR{AfP z-eNKXJAZVrJ)sS8jubkyGuRH)pB&KFFR%<1b(Cp-yZn(3E7mwr4(GY!sp;^BnY}M2 z=FHsSFNt)bq~3QiZ#6Mv^3r6VdA3X>RD~YZMVMY>K@F@U6xmqa#ji=|7hEo^$o-wZ zjWQ^IV=z`*i&sfgXCOj33`df;-hA?KrY*>=|8Wf8;m{k+wjp-<+deFGh+BM=D_dtc zIey4Y@?n7y|Cgo@nkOK??Jjah>2APiUZ}5yo@7q}5=!)okzbiHFB*^=3L%O3>OHF5 zk6H7uFgLNM(7glw&OK2F1UHCDUMxGLVKufVNmi%^s3SBmU3)8Tc7}}WUMaTT2wqq^ zBOtlOY9arAfcbcgwf1l;)waKRsLsv9a)Ft1>xgi0GGa!{C{7!}Qb~lMjIX9b0;(GD z@Xeo-+nP>a0oH*=y*qq(cNY1Pnmt~CQq+rZ$sFJOK}^+g^P-q~RW242hHk>H?EHW; z#l=D3uol%;IG8#zAMwg}9_yx5da1CXg35gme{gYgGY`1EO)$l>@DrhsBbrBUUpL_j zd&=jqmp_d8$-R$PFK4CkWKA~Nf6*rbY>&WvFi5y&90B zcU(Zw_9T?qRrK>Q4=w@shA|`hoqs1dWmrdpKQto16IScJyCQxSO&%_>M+-*sNeV57 zBwMU~g|M&j=-Bz3_Bc*MOlM5vsJ5B7jly}Et7rNpeB-TI8N+pQ_ME#?&X%)txhE-8 zBCs?WY~;T*iOz3^kA$w_y$vTs4NaU~D;zh|sueYeZRM55`QOrac)iwS#;2kz!(`=f``dP-#$m0Q( zGr+{3ZvTL4BjFsqMDJs8!Zxy&eH$nj>#c~wxs1V^eGP=w`|`22ymgk;M00o}=dS_3 zxneYvtX-!3M!-N@CbBYJR>NKRmOLW!9F-6(L|sxc0D|LVdLq@ln;9x;%=i1Jw&`0cZCgrd7oY3$cM=8@N+?HByL^oOX^pB^n= zOg?sC6_bz)Pn5euN=1UIHi~Vq;)vXs9mHq-0^IrZ^mJ_eWHxw4V+B`?4T>;cnVl#5 z#~p$g8c;H-RZUrm5#So@6{UGGytTF)9>9GJ{#`O`lGAtJ*JU)^A9~E=HzgR(D=ym* z$$&344O#2#&9+Aw^9&0)Xu`gyoG_&U6oZToRsIt2%V%-RH#hQsJ~voJ&BB%$#fg# zbNz}c8Aq4zg%>rm}I^6-RC*QX;~|3$mw zAVS*RKm}o5#jtT);iKLtC*amgw5usIL}8FDg%-L1NQDMfJTO>i+-qYpF?16rw9Dgz zl9{3}W0oyH517C+!3d(3(fW#h_2CYsLP&>Do*x+!yJKZAe~8~c>{Hl zWLTh>Dr7IWN!eJeoq8Tum7wShM1y*=Q!)8qd9W0NQ!!SYoRKlI#RH6#1q(FWpL31K zmMcFa-f8qY)HLlmi&aHSTekCnE(qec?M>zU0_J;eydb14(3hStNw(RWOrF(xnK%A* z2<@v^Qw^mF%CRB(L9jth> z1c^X$db+hfyUh`WLzdwI1XMhpsmx}^MaReIL@&QD#m#02J}dwb8xYONmy2E3Jh3!} zMLvP8y}VfaZqaA#e$+4m=6I^9sD;}jF1Jg5bY#DLI8(nx3-h36oc=3O_6EGyDoc!W zdAHRNbxdm{6exk@`l}kiQR&lEK;N8|l#x*06R{$xIZgUW17(8|qp-+=w}T~I&$|wC zLWROUUnGRzt9V!CIYG@iO!5w;RkY&v37rIz3colas;d{i4RerHqfPWfG*Rcn+KQzR z`v=Iy3Z7yhcls^Azuu6TbdWEhpio0K?$nrF4T}%B$|J!oHSan}G=d!r%P?GQ=-@OD`WjW*X z*8r=q*g}>|k3mc}sO(t?cLkwdz%!BP+6zgVwVqYy8Coa`!D&XVqR(8#&laq_Hoy>X z;G7ix&nAGw@((ppmh}D#^b;>ryC-3*ThwjklT@-w5NVyJXWBO~hO@bw4*N^TsJttZ z`ebw)8Ee0212BMKf(Y*eFh3%~aMGrf(Uq)QgpKRxe!!8X2A}6|PRTr{MMs$?9OkeT zqrP=g7Qt&_Hu9Jp+uD@))&dSV41Qw(DJM@^>MzP3-j1?;6DTQ({Cob?e+9T^^Bg4& zI#5kS+Z^C`y_VmYP9Tf1H)eRPzN|Ac_Y9cTK3+p1^O6)j)Rt*Y{}8Rznb2b+6CidQ z7{Qi9MZ%rkrNSXpOhoQxUtj&DD_a7bt>D%t`_Wb}Q~9gz39yKZkj78k!B{0{X>5xEFjiZA(@f`v{4oT7|%bUwcN z+5Hmq=P^-4zh`4^#gc~pz(PbBVs0DZ29AGJhqMZu@q%n;w(c+^2D;UYl$Df}9m*CJy!uTzKf)EJCFwNaj;5UFggowzYi zS534v=%DxogOlAQVKAqTc};?hA4PMOA~4&m|M|RDFuFk>LMG@&lTGMInD5-MsOJq< z|Hy>kP-m%Egh>_BL4#Jq9ydF!G?Imn2uHIGk5^^8;!8NMf+1}#SCC_*RfTn!2t`ar zqWe#PAagWBIEV>!0>e+uLJ>bAr1gu2PU}8a1!S z97EMoG{l(ZZkBp}v39ka@?9WqTf4sK_JRz#U$9818>}4~xaRyPi=b~IC$uOl>2%S7 zcc=2o@#fj)HerMH4{0nz<#<=+Uq~_i*ID`t2JHI6(Q~2I+=~zFSMpr#jexEn$qaX@ zhi)gSOsIX0;p(Ar0roM+GJG3qI|$*9_}xjU$c5XB3|WP5eFv{3Pz<&UrN}~n8f70W z4XI$3VKzKI!u`Yr?9G~HBpYJM>5&>D{`mX)lncu{MKfOjniGz+&DCh&G0JrE09JyT zX6skSOmOOaOxr@4J*%WKhBSC5e!(t&43-aj0X~^2e==l6^7l4MCpPh_N~h5RStN?gp~OZ0Q6UMfphpySEbJz?bSweuK9`fRB&La}qW!&8763 z?cq`TW1??t1_AKQzZkL{^I2TjY3i6>#;9QP`WA}sHMvEq?0p?^j&=-S<4R(bI*7Vs z3R|1DO}NA`lm?0qxt}+XQVZit;PI@hR9Zko7ReRte;)3xlyRyV(82|vZAY^^V(;)E zGYBLJlZ3-?cM`(pbYZMZq_mJ@J&)pxu;5m7zzu zTBuY&4W!H`I=|@LxX1m=&&$Mj%OYp!U2ugc(8rPLScMP;5|joRsChxm^0#F6;wox! znqFKb9JTA;)n(7baU!?-W-zUr`Ud+8MCH2}ZYbP6>3~^GaPb-=IzC(VbSw+2i=SiM;W!r+-u`0LA5~~$vcEw59sp*0T#BxK&o*E3@#egK9$JhfkG-x zr9t9ZD4IC*fFKG-)EU^v1eL@;`v&$X)>A)#Q3gH6?4s~SF1?3Tz9IC(XC^YI>o@UZ zWY1{!JS7{W*lCodDAE2efNKRgZ=zA*VXO_8=8OBv^hqTr!TRr?d!VVak)mnrQ%W_2 z?AS#9etOCB-u%Utt%K!Wj`k!a4}L8cF*te`YMIRfDxAcx{z~QAYp*Z;!r@GTq34Mr z%bcu&LWea)teSX@K2&On+reWTtpt`swMV96>?<->$xJX9$G=j0ed+M`Yu|UQq1h)r zvXj?vRc1|XZY0=WJkbT5+^;t^g)X89AEJ!C9f1*rCJi(?3~ZS!0GP4;|wUM8_zHoZD} z`?hW@yDTso>MUZI&JEsu$7!^;(Ivs!XFS8qew3G!scn6gn?o-(v>P4vfEZ5!v(Kgy z%@x-;3fqG)eSbC+phl|Tz;uks7JFz`4EF1H(3D#vBkOtAs162*U5qmr#}@wUIKsea zF4OzT3t)j7<~C1JDpbQhy#WHE5{^{s`XeRYaETnmc10DgjRy7*Qb7u+_G+vIk|U43 z6%BEs?bWXTRGWAcu(DP{FhLb#4nDx&3bgOmwZzw^^dzNim>~ogrOm$Ug|8`;)3=X~k7PmMbj_m5$?#Q*mrQ696zUnzJftTa0;WM^lCI%e0y02h<+ zqQ+6%&0Nkd!=;fg*`B5UA;bt(9y=-viC+I8LGw7R4J|4U6{j==+aed>x6}9^fEA(C zu(rB}8A)*MUF$#~130CYjr?O)mGg)z7UTbM^_M|)bX~Y88YBb=AxLm{hv4om3kmM- zu0evkySux)C%C%@g1fuJ>GghR?_2j&@rR;W-Cf;l&M_VvfKc6tV$o?JjiLcL3a&L?{eks=d`sKo|ye?&i<>UDw627~aAk8=E)4;+M;b2N0M@ zPrz)EF9j9rg$X4`tG2K?Y?V5l*#5IXty2$dI?s{3{n0|dnW5{JpY(}LCW#uLoFBq% zy9=3`!48pzI;X;t4-zafuc2z~2)x;+Ko&;IsWu=7__OR6j>}Rop3Z&_5HG(b`uP}c z3IJ|A3nTzsj&UlSHhkm}&;{v5qluTD0*PQ5ZS$QTKf53R!99PhdCMG25`pB#N7HZe z0wmsVFOR^#@(tSLWTB*gI9M^h`4~KL4u7p5`)RH<^iv(UQlghWg{N2G)IiOu0M_X+ zUGf8&L;7&q(zyQ9fXfezUnRbO+A4~(=B$XN8%e@-3<|aO-K)&713;5u%sw6@=t5JV zC4@%Wim4bF5F^IAJDe>B?2skg6$F>B|A1l_Z05u~CHNi@bqo0Ky@3pHz$X6K=6nn* z?eFE|9F`cey1MEM^=YQEL!EYIY_h{V0`Um|&HdS$3Nu|+N`a#9qyS2@E4jnq!H8b7 z2_f(naQ^*v`Z+`tj5HVg<>(G{bsB}~802PD?WR~tNh=!y;kY#D;R#J zcmW)CpSZKtDTr^j0P}Zfrm%`x-;UF5@?m5*VsarGmmuJpNW&7Lp`lR^CKh4x2;s;m zCy_B!BC8#K2|$&_t;@(IG6F506};(tPW>q2J+gQo;IJO)p|MEB!Px^&B7r zcm(jm#N^~`K=)Fd;Q+6ZkXiEe(?@dc$j{*^;IvZr0kFIaaNRC@V=oty2ix&!MIgGg z1G$v#pL+q%wDvNCEavuI4lEuebo<39m%5Vif^T z#y7}+U{{H)or+Q(@oy7$CuEm~&EA`R{&y_7of750jUV`n0jHhQYK#5%U%-3s4WxdQ z>V49!QgWiXhYJOmb_1iHFqkU`g{?#ITLFY0h};V<%5<>L`vb6Y4$=h*(*PoDu50W>m^MVGm&stg%hUe&5kPX|Mu~#5fmY(@NCMUHsmfVpUfvd< zJAt|bC=T>-NqQ-jG*A?{J`dHp0LV15a=H2F|D6O5e3D@SClR)q1R zPtVELk|pV8k?a)~t4O8$ARKJnOl57i-N*ZGg38hnRoDk?h+UMkSVU^o8-v^{_u=pR5K?g525n9o8z$@rc~%TT4; z-BnRB1{FvpXrp{>M09bK$O~C7lzCYZSkX#CpL(W?$p;NiV=kT*_VmJ2!OBS}C(*TLOW)JxuAgSj3pG$O{GG~&}6SW$B@(Q^ejD3GL$ z4wf4yxS~FJ@!Vmh_hrPzp|GIfE-l+p{KUEM^`nxwVIFER0Zi7w4d$~6hWNxY!Ohgl z69ox@KwpZ7BJsGBltrb#Qgs@;BXzD_FkA)Ejm%y83qZeMAbpqXO*Of0_L7`s*cQ~y-0n8EPra6nlZWT%}bzhFVX3pC3>>pZ+O;xg};*5=s+}sxFU(UMSE4KC;qce+4cXXaz=IwZM z6Bh!=mv9%uT;8k+g85L_J3XCqr_)tjp9?UbsWMITEED@_?J&i)(QjXwV&N$OZ}%t* z;^^kh%(d&mJaMLL!@RB>vRbQyvB^Uh(p7BZSFcRR0_`v)BYu92kWFs66tX;Gv~S-w z;$>@K5EQl~u$0Jp0_s|$Er8Y?h(I75Sp}0Zjo<7G+iv+G*S=EGuYk&Rs&{c&f0r1U)96o{agj|}>)|?$0 zMxMx|nfXL`X>WG_DQggI-~i5yo%GxTi3mN!%?xcTA}m6d!G=O5YZRp15BAzl)1nz@ zzu~^)<^{*yfTb=#5mX4NFvrOmB_A(>zEQm^AB*roJv0Uu5@b7()oyY5bAcXR`DOFw z2m;Mk+nf$|{paCAXS%cZaddlt6xE3hW=&6{f=^1uCikmdWk+|%YoNVu?OFKfV&z}^ zOJz>svRmvm7~Zyv#M)L3U$RV1?xq%5p3z`rqJ3J@rJuB?qC8PMpN=rMcn4MqZQwB*ul(SbF4U@lJ z)3dSw_{amx>yqKcsWQX7X1yLd8 z-A6cID=%WThuZy(Fgd(8u~jxX&t}lUxHYPONTRao0Ju777p09AE)0YNEE8?RS^DLkjzxc<^HK6fe-KzdSWM1S*<+u-B&mn0ZMAz`F@n%c0TcViE|_vaV<5z!v&G)7uHR4)3_UpLFj(zINaC0ak@?#7c)3c z(hUe|U`_ZVzOfHVe``KIKX*0QyU$hGeD~6_+s?*k2g$b@;gf%&KYeRqH z{>I<-^cVE7WxX=zs}kV;f3yI*eyUl2Ira{ty$Vm6Z-TBH25r-xhm&*>yDoec7v#F^ z&nVWbmiAv#f4+I$Pw(&joW^9KYHA@3mlTjIKwuOt{OD^&sMzaof9WH#>Sv_MwuUr2 z6GtL15(M-n6K{?&i>P5lqI7z}ihxPAs>JAnK`4T!i^~DVE;t{K3q$h=c0i&adm@uN zxHwwweV-)}$b|{6*#L9$*?gWGDEnWRlCsmxn7cuJKb$1AJOqbHll6VS01CAjqbT)~ zL0`je;6Fg)dco99nk5ER}vAYs3H*_3V>G@h+ zjGtX;4)vtV{^PmZJi1=%p?eme+r0msmoIW>kGTluUBu(CZg}R$LYS0vQ`VK0pL$W! z1~Imw6uRp6mUl}X9lke0H?KJ6rEATpXkHh%e9w!+3Lz5R^2_;-oN^f}j?Z~g0|Xu8 zN5b#QQCJ$Jp%z{PYUusn@%p_%p%{e^G}{|I*Sl#ZUjew>!aO;Ivf?isYHd6lGOCi1 z#st8a5l4rEk(}R>mejc^(uI!AX3EGR&KuqLZBw-Q z1g(a+A1j!3y{}3^D`}b&-8403S_c<`Jn+!UwIqibs{B%kZQmJ(8 zn=-)WZ$*Pv@4`WZ98wAg;D))n%^(Egq7FvJh1k*uT>9ha*eTbt_ivE+#5IdL9&13e zQ*Sa(Y_$!f$oC<4L#N!ubODBEG9Dl=KcjNA4EIefL)le(nGDTXWnO~RpwW(dCV6^R09C{B&bIYm{y(_>z zl&1QD!>I`L{uo^;b{wHv&ENG)L%VO*TT@l(C%mr{M3 zAFC}HsD`p1y6o4jPj1q`&feiWW>0I)vMGI~YTI#pMqRnNvrNB%SquI;lU#Sq_fR~| zQ!JifCkJwN)T!iQ`0gC30D4t`eZYh;*IpUaqFw;no0cz`=2{|w;4nB`{Yy9A9 zWZWqN6^w|>{S#crNnk%q4O@QPZKI!e^1h_6*0~sS{Q1>VAyj2Nt4--VZ!{!M=*@%f zVaMc^?fjs(-K+<`aDAmJ1AosVt5U|868aZ7-{cn)QrH(7NZd7_!r*Yo8_b5(kDt-O z$}XTE#nVs%Z0bNNN;l9Hq+2`)A-i;Fvi}uCTA;u6SYo`BEmu+=-uf>KA!WTL;iOCxENo^6|+yZWRs zZJ-0Cc5m@v=&-Zcng1^Dn5LSqxn!_hu z=PdP`%W;!`1{gu(2P`n;{83?B!+yX243IH#jzys^FI1@aO4^BdZMmYNPlHWCSDa~) z`PR!jJ&1&CKj4}{F81{pnV1k9vabMI=-PS)%<%$Z->Ny`lQDNGb#RqtMq6k_<|~B= zE0Kpd+l%yf=sDNgo%b4AjN^6Z=E=R-SwM7jT;5S#6)G=F1%k^fZ6QK7C7oLZ{QSmZ zga>Q~UET{?JUPEtu2JK4X@Ra`YDGD8_0=kL+c8E?`0n=>R+MSb*>j~N=`(>JUKu&ldwiNG!aR-fd*HwpyCkkI^ z0dTVt?h#N~i1=R|1yJ48L^x>LwanA}Iml^+pn)Aif*Hc-C^SM^~; z_wEd2DF3~wAM4mgbMf_f^Aqs>nVfbk&it3yBX2air>jBEc>Yq=oqhLYO#@%8Q(^9r z<#ZqZeqX#wpL_p{M!gN+c`%MauHz{sSIo>WQ+mI{PBi=db^o@|QlW;;{8f(2J-RC0 zE4_T&P5iIHa9Y7$)lc_Zay#2_6<+XzJ&PpU z;_0$3?v|+x>N)f>5l~1PE|>+Q<8$prit^g1*-g!>;xB*@o^`|{u-eO;SMcLul~E=FsILu$ocfjL<8kzQi|a-v#i4RLE_dtZGY&hg_x`rFyM=ZG z&AM9MzJE9(wtL-y$vb~%?VZ)a3DzM*}EX%-(QOV>O^WZb%V$#*{2o< zaH8^Y$1S2`)}CgCC6a92J;su1J%D93%r6>pNX~^Db*tI894uo0@3Hfu3S>E(XYS=9 zEzlB)0{t!4N0v$m##C|KQJ#Bn2dpBN>Q20E;C)V%Pos|FrY6H9N-QgQ$8*>w9ux#k z)o~)bCdcjMjBR&kSbT!h_4$>dy4CA7xiX(7F@vOCBB#mjaA}w=y?+IrhNh{ULZvC>5|Hsm2ys1=|4V@%&|*ni&M!P z$RhgWyQ1)zNF*1#^1EbZMM3>hG0kdg5eA<6w6)2?Xl`KwW7#3TXaq7|sz8id4ghli z5|I=r)8}HvG>6luU|B%J&6X1V%HwFaWNpNaWlY)Y=egwt?&faQ7oenEpth^3q~84m<4r?giEHol?~2RRDJYEYUvTCHgyT*vCL0OK69Y zBYy}GP1`^D7!{SBFD0<%0?N>Pj8%^i+OcIcBRD)-I7x}DQekc-82Vx}*n`0*@?;vI z`dkH85ETQ(bz0uMazAFFA4!^jO3ruP{@+A*jfDFJ=Qu%*=R8T{cLhpT& z63G#|!p2~w&*b_W5n>1!`|BawQq7`Nn96D^x?0^trqs+oAFRx7m*&ip6McFYh<(^q>X%J1)5ib{-ivPvbH%BqaE zCwZKp6%G>k>y3@0zsKZz799Sc#6Wbo(>bcZQfOc_eL>BO!cwKsIS~GRVt1E3l1P0% zrNTyAi78)WdwnQvZ%;DuBkJ`L1?!QwzdlXUa!zCbLb&=oy&-Xk=r0mMY57?5!l*DR zY`9O<$kTQu41mW5i4zR}2Bz>3W$qW)?x#!^+p}qk87IK8=nXSU_csY#tH`!k=am>C z7+k`|N!sJN^}q?*fZGr<0}=H{LFU;;cDk~XuNL`5M{Sd3BMy~$`gS_ItYnG3LTBQU zw;I#mtz*4h)P(hvR0J#$$Ec^pA~HD&sW|9A#s6@$5nvZr-o*-2AWT6+UzmSVEvJ$1q)q5+VtP82aiK1gK!D@Pv|sIsVV=5DP>DS zgsJrrU$wl<0m)m|#A0JO*O&IP-&7CNA~!3Pa1OYgPo&nel-NwI-fBiR+rocNSjoTF{mK1&6VQzBMbjZKc&YAxqrzzNU!goX87 zwJDSrD)zx^<9Yo7Hz270=Z5}24M^VBGIYHR-S2&iK{%M(2rSR{&nR5YqnI~S1bk3e zbmsbZJAaxm6f7S2S}ch*fOIIx3BqU8TB9$W5yD(W#<&@S3RUJ(N2`4m=v0DcJ}542 zfov_czGn*`s@7W==Ofb+@^_)(rQMAKRX5d~^26=_F!5v~WWoVg&K(xWd1c=IgSnw9 zXwQCi5vEQGeQjk`Zz<^tzFfMlj1|#uKHQ*_7+$)lu(SRFncLn*=-n?&X0#O$EE?J4 zmi&(mqH}fJkWvEpo#8yB_+s9}oe9QlxtbJ2)!GjQHfR92&QF*#h+JYZ4%_vwEl-hl zE)y1w5@CM2Qob@RpL0IF6K$L2pMznkIXa+v0e_bd^k7BoF3Jo( z)*ag1o^ClQDm7oQ26#TWADm7VDp3-E(E7vvyJj;2@Co@^Xv!3j1RTRq2+WiXwe=Mg zh-zyrmr!iAGMF@hwP?35x@dQ0DQ|ffx`Y_n8?Y6_3`_y zt7sd(GGmTXL4@Y2&*}i3#ad0Mpr!GnJw|AL6TpE9oeTw`}&MDq*Q$g#4Jb|zOoZ`mGKAgZP z|KH95Ft$D@8WNlA zVd@i1?Qcp%$JuHwL|q()xR>#AO!65w1wQrF21 z0PkewFsO|J=?-vSHt!m5E&G2x1oDOc2=SiThjO4-8JRmCpi&5a4GSw5R0#3)`HFn~ z&N2a(4((DTVMLMz|3IgL-4XR+@NyqblnkFLzuSmJ1OX+;e`UriAc56Ol{mAB%onvd z5~c?cyWbY<4p0&Mhu;z|Dz#9_v2#~4-PXWvzEmwi+g3WIgT6+ma=P$V z2mvR`n`gK0IHR^qeh#B<)RjmV%#fv#jlQP(BdS%8qNK7ZO}|%J3cdS&NjJhaZ(28j z6shO0aUlp2(V&2BHw=PQxnCL@915Zol)NPrz^P9+d0{$pt{y>C0o&idaGq|Wy7{bx zGY8pYnyzXssVxff>^<_kdPzq=q_KYrtd7(9+hV5y55p04N^TuzV@-|d;8j`0Z+_B4 zGe&1f#NaeeLk9Enz`-FE{9pOmwifc5?6bCG2Bd{*yHY z(dJ{>Xenu{Dkzr83{FtPm5a1pcm_pVD=(F6E#`&!3st5P94NE8G}bC0nwAC~ zhxaJJjAc4C{=sV7PGBn&Y3H-5!^W*BVJOw=SFk~g?;$UbfYE?kBtrg9l7|*jQ@f;o z{pqwhTR)jq*cKM&$7zc2KnAlszkIkhb}k)urGZ^Q1*lEXECIjK-*}lZ2%^}SKUk-` zpAwA?Pml#^>Zi8RZT3vV#!D4T19s5*`Rp#iVNgZ12%XoYM)VxlV{yeKE$^T4UJ)z`LJ>4+zAon4)3}|z zJ#d}bxLx+g3;P=P2-z#E<64g4M+oiLWg~HyfyCHDjw_`?oc?W9uK{(I4Mdx0y$VWJ zZVl;sGISa3&f8)ow9KG6&TWgE3*uX2UJ#a&5D^kH_(jB`R%Y}^`i*4#mtY@rjLP3g zH4l*D!9?KM(7NpJptCLDU=RD`b#dW>tO85$4b*I&lGy3B3zB!E(Gxj)mM^f!Xe>g1 zEx`B8AP-!*W^d*<_D5=57APq8x3$a%8L`3F3r?CIf;8{Pnj#=XTitiFdc{LiNYdDt z8lbb;32leNSlx5&10{}m=UB1Nq61swX7h`7Bg&_Oq!x2fj6 znh06J?o_85k`pf!&*j1uB5QK8gsSN(nCteTV0~LLnK9-=oNz>m1zXRvw3k4EFq3q^F3_)1==o&hwN@8TskEdJhM0S}vA8gJ1{Be{}& zPfq(&0W%?$xM?C4*-=U_3=(XyA2((?V66eMMR?!;e@O}sg>-u>a8AQO9fd>3-SSZL z0(kg_pq?HcLNz^r^ZX>amlDWz($7wh-r8r4TetLxtS!1tjfmp3BxHP@w1-vfl7?*X zK32>w>*21q2*njiLh{}ebnjucax*$hkVkDta2^-iFm$}m69%g^k$GTCj`{ZjF> z&23bL_cC0;bhc=UPGsW6SgcsK*h1sX`ZoOTZT+Rb9nnMTMv=>On~!%PV=coLX?%Q= z*NzhJ6+vO!_tCAq$dUpe0w(kJFN)2k^5rHER$7@wbIG5zUdHG|AN{zWXcrb%ml0@q z={@(FgoTzR*v)2(?$d=k;GbT!9ZeP98V~feYS^7;!?4D=?5#%^jug3HnM}7E;*I(u z-1oATBEuzrOHfi*Uc#<5%4{$6d->3$o5?V#Lg&`*g#0ifoQnZchN>y}aPBBY8p0L= zh{5&(fOg*9h`G9v9%T89!%;mV2l{V6{cF>1%|(n9X-eLT@Od8Civ;61O>*(?Tb9;6 zY>fZgOCh9Hs9z~qtTGA3C}^L@Dm6{RaJSE=Ql*1|FwtTdd0{%^*?;`QuKV%)b0rzv z`lbKaWXPQUCS*1OW4xOAaxt)!U^JhGJKOY+=dqOlp#wp@8D*`qYJSt-vk%ktvF0yW ze2&+9)Q_XYT*zo;4D(T5<07&H^e9_jca%sxN7O9&ff(nR;Ps&lhmz5g<$6mC3;Dz- zAe=jvL_81Ee(AFdxfA+B#vpqc43=nn&I%;&km_y)Viz(76#FXf_1jBQtG1($|G zg#O@@zuY-{+5RdbozWx$4Up~}-7}Ngi@d}W9<$uov@@Eu_ zWCS&tTG97BuT@CZntZg=A$qZURtx-T? z%8w`j#Q1?&ON@jJQ2_!EtI7TwQfM9vj=ayd>wyD?6If~3S?V)kB4jzuNCI&4E1;rr z0W#LbR_hJTx9r*hm#i)zYy(F#hySct?gZv~A|@&;U=x1tc6aBtSLe30FdD%X!{W0f zbNHB8j&uPHMEHDz#&xFStRb?x1tXp!V_%uHSpmQ=4kCn%;|6R15*6)#xZGZ>){TDC z&(`poFt@Ns`>x*u1SI|h2@kDjG#0Yxc4(4&}46aKYXA4P8?T`*#2L!t^PYSGYs=JM2XVjL+XzbA5v@MBSg?v5%E0(W|SD9 z)BdiPf7Np^A)L*^G1^(EFZsy!6KzfY=TyAhRu5iEyTR`OFI9%cC%HG%@l=nu^ZfR( zCy<)h{Oa%*>8gX*o`c-^(Z-{hj`3OP03$kY{wfZ65uuSz>;5**Bvoci^?k=<26c#HZ!;g8NI=#Aaq)b>W zm?zFUFKfLvW2D9SSG0>0+39Dmu9GHh_)d#D$hZs%)}1%#TBY%4#V|l>9afK5zgJnC zaWS8Be&>E+)JCi_+oqJ_O&`EhM1TJ(1=ysPiIm3D+1|^@t%ZzAV*ryOJ*>3Quh!$^ zWA*(f0Ai-|dAPd+;`Di!Tfif{xZ`WXZJSurYwXmOl>^IT)Dv#{R$CqA01D;p^_e7a zDiv2EC1Tjw?$srPK{Os1Lh3b3kyGerXwZtd~VC?x$NEIPes_2{m0bV;IxoN&O3iG+=VY z-}Sf&H!gou%)Kb{Ki9dwT-(HtK$I?;{F2iK;y>JO5B?-R8)JDj6)C)<1 zt(!BOPTADm_OtCjltPHAf97`9n6LTu7~z#!jsEQlQN4X_!}>;d4jJj63l5#UMuj1_ zk;yfZweqeqi8x{|2?*!AJU^YyUx>^rvFNGxiTv{c>t-B>s0#C{5zST+ z52hvcrQbF3l~eF_Vp)badQK(gjhS^#%P#HKNet@$E{s0Qee!D3{==r8Sr<6+FBJQ) z@u7p$7HSaySxfl(CYYkq=Gr5F=k`)7ozXWo&kpV%&*?L=hW}ae2Dne5ed{N-7|JQdg#Sx|2JxVur%HJATY|rU#@=&H} z(_qFDg^OqkjM(}ADJxe5e0X0dWe&)Sv)rlOp>n_3GkO6tSKPXrrkRZUQ%q}KGXUwB znX@aTe!(X3Z^IGTCZ}K1q8OV*4f?$>PK|&vqa#*hWVOI7G4xh_|^#(?cSUS!GtnCe*{y7ZHM^qjas?JyY$onVhrmuTTDgGCm zTxy(M*Sarryx8ifqEcO&Z!r?ZP~O^E)o12XcDLGKP-;S{j`LmW{_pwFRS*2Px~($o z@r|$(Sty#to35AE*l4VVNJQtz%GwUwH|-TPB#TYSi|_dbvj;0#!eW-F?#G=vipi!F zB@W*psl){Ot)&=$mw6<^BCyhT-5-3JEdup=AA|to?QQ@OFW6@Mm1oM>w5l9+w6?11 z49ExZ24+jhvqo|5Va}1eWL$>1tf?A&;pl}PJYqB);CZ>|6%IlGYYk+9z$};3eutW2 z;D07{ngEuS@MG>$sNt{yB|IfEDvF_0qbvAEfVzn=Jj0=Fu#QfTLq>&VKrB{{TjVi9@BSH9$?F-NoLU{%SKmSn9?#CVlrD^ zfV(20g2l=#2a;eCz-jOa!WFQ6z8|EZYEfIK48a2P{%{O_z>#ZZGnkzEkv8dC&DMYf zXFi}>7?;${&!7)-70_|lSu+}3yd+6oc02OAo)D6DNXH;%~Pd1jpQ9wZa_;m$E3TA(h|-#<*!h{ zq8*&J6{}}6l=B2jf*V;AV6TCT5%x`mEPxnw7YSrBF@HTMwRZm5lN*+*quvf@vfDAjse z^khP8y-5RU(FLImwyHbf9<>6jxd*0b_WgPTg!-#^umGJQsAtbDxQ- z;DCbCV}uiV7JZMd*(BbKSr=ruP8_5n-Y3oNF&z|F+oXz)N(e-^imgMT{DTF5ycGE3 zR~MqU-6A~X>mFZ0hS$VPp=9FUh@iUrPrDVzvky(anh^g-HTalA8k5g_W@NpwzJ^iShHf>lS$-Po(9_s5V-k+;5kdcK@_ z?(R~D4QDq3K6{}h78)I`&8nMrGg!r)o0<-eCcXXw<85pr_v>I|&J4+9RhQ*ABB+`i z;&#UZUUWUK#J$m2liWjZvGIaS#uVa=mE1^^{=trj` zBwX^*yKVIvC`B%uzv%1^h;_U-dhOq1uM;-ybCR5}L~fFgA`Fjm zX&g*r{%!Wi6Kj~7Y(W0ELR@O`RdV{*q?|N&z2ZmTH>hV+&o3H}iVE{70gHTtE3Ps-nj&sB@7*z^P9C(D7vj|J}q4g72fohcAmEC=;np zpaXc}25jE^qLK-empTpRtcCv59?PX*!WWghJUDh8v8>%W;E%sTh zRwYCnDlOPnco(2Xk^U~uiCQRK#ldG!# zMJu-@DeA&}k`fNM8bBPKj_-8*s{wGy#zDyWXxv`l3xZ)XRoTeDjQXK*-`E@|;lBc*m{(fxM3 z!uKprb!ogJn=uni7$)jZx?cHd%G<1 ziD;T;{5_Sj@tM~Ecjd@Rb4Efsj=?1uktPmV*$ulZL&wI=AX`*vubHjPk7U;;t#MBa z?vmMcX#gCX3OgI?94mX?&k=vN&H57!57R+|sSO=p0l2^jGQ}#Irp)|e>7P|+e-n&j z=}lK1^Zg&&Y-ejq{Ulv!SZI|quZts7odflMqL3X`3*}ftDT50iWz4_V3 z^&CnU4CSmZj}oDG{C>FCBNfcKyH}V={ti#x{@l+l0p007S^8TUolWPLASr3GJMTgn z?+E9J1?2JvU&20r>&vMhIEJCi&zWv6rWDNWmgGjJrlwujgL|p_ZeEk;kDgh{ZdYT> zlf8LAO<4z~S(eb?)@7DkH@yK2$F}1VX5wo0PI}m#^s`0XM{2!8fyRdU$+v31cMpd& z^d!yoo9qtqI@+S%^}eBXhqmg$ zOjP`~9V2oFv!^Qu8+bD|Cc$BDgJSrMIb%-4ak}Xz$6q~Z3B?Z z9v5T!_KY9O*|#-hYkSjP476UqnP!2HR-8C=a3-M$Btq^nAK?D)j|47TEeh~k3Lzmw zWn?unBhgR^sQ@JD#s^4THqIO*b4WNf@tl?xj_ESZVQVcPk42hSOFE}jT)-*u<%qe2oyqJ2$bK&rhgu6)}dqyvJLS5LU}x6B~D8aw!_*j zC1~&Vuf_ovA;1qOB4<51oO%=R>q^6^362|bsCa0zhst)uD-kpeb+~0ZIj$R$zdkXp zzC`LGeYMfRp)Me6*Ww_m7=m}E(oi-@2uG1UcT!#*Q<&%0a#Ck*fJ(0Jk;s8Pxjv_( zN={(NE(zC@>g3hUVNxZ+hb$N867I@jA{**c5JnD~;QV=n%7Z96&`To>?clU7Pl&@s zu)0+a|FFG?neg4q0y%&@Auq`&=2VhapQ!EtPd5@gz5MCM{5iRcJ~)*QL)&CZrZ16L zH6%u!IxvL(EtVB69UWKfB`b@SAc@vOOw~u%t9>IBc7cHv{wVrR9uZyh zjTjb0nJ7f6|I0#BZ0xP2V~Go)Rf*vwKj&J(|Hlb}iAsP5uJ9ORP)^n?dSk66UR%)m z@-nBx&Jfs+Hqi&b9<#HvhP3jTbQ;W&v7%;7u@FuM=p|F=QrF^}cCRfN9sziPssWP{ zow}KaXK!^B#P5QG)h%65M=Oc%Y@S*ZOq@EqG}<^6cQ+HymtWq0uc^lNlwH}9nEct1 z_?uj}(V;%8*Fp-Sq+0n~*A05gsWEEJm}?#_hvz@?l|Wcb<_)9Q#+SPLxla=+08@&l zGJ*LStHA4na4oYgnzC|4l43fWr4H!ff=ANqJV^{g=HEU4_!=5-XZ&Y|cxLojNYiY~ z4}p+wfuh+?eP0?$eezt@1;!xJz8mXlbhM6ml~d!Ln3rB73rctbqwEJj*weiFa}k8B zALnCbppi@ZA^OyA&MF2D0FIx*s@bu3FeqcFpo&I%fka(Co=)D^OS#zi>RYz$NY(3z zK2_LhcEuUtZvY0xyL>QTbFJ_`Y7-`~)8#_GL$a@WbEb2Aj>H?1`gpros~L&kC;Y0_ob zu(XPlC0Sga)B&t&5~4XdIUi6tOAWq{(L?7IH*KniKL%-0H4AYn$x@ftL@JfL@p!$s zen){TyN?U_dS--dZsmOK#RyCFwShW&V;Jt=U@lIt;2|F^&kxWguV(yUlfrsjqDuAGdtQ8P^T z5yUL1X9v6S>_}UQnbD8}4?fZe2g1dBS;b(C0nR7^2=M+So52w~O)Jm&-yb7glT|ZQ``F&Ncqbt3Kq(X=mflILiDSE)2Aq-b%;Qil zQG8waj9bLD6-V1xFWbaVC6ec;p(i@kF_Pr*5~S*@CH$gYFfl|+w2bwax!*y=I&0#L zYK=M9zBVuUK@fy4G0Y}HFZ`xb&~QJ(p+ag8*3=_w`8n8V`sm%vhMFn|41{H^@0k9E z8W+`$dEu|$Y)k2L3pv_6OkSigO7$IlZOR_IM8tb8@4RhY;UoAb9E6C&M%o79>lMD; zlGOWUvhgWtu!#~W^v;?V@5`U)U+;WYB~M17MR;<|Qeztgiv~;Cl1+u#lhr}ilV8*$ zaZQS}3@SbiCaGCO)%L#y-B>nJsn7$@pLD|oGG8o`3kY*wlO>`#vAw{kJdG(RdW@%_ zqS)K(lijfn!;3w(^&_fgP{@;XWwcHw$@NI0NXx*^qj z3|PxUIdKo2^~PW&dOJzGNP>?o+6YKU?x^BGLmn6GCgyo7$EW7e%3QWkR}Xk!w9lxv z3MXY9OP<7>m|lWBg&j!k`|<`*I5JUX8FILCN=L2+WyC1FC@sU@ik_}+UMDODAQ3Lf z90F(#tD{e(VnpEj;DoG3PGe~%u-DPj-o&PTPDvSAgM=W{!w6I&79pyq;h`<6S9^kU zDXqCxWDrtcDs`C^PU0G`y*U%SyKSpmx~j4sqxvdUX)9=0?oc8vudR%6Pbp7reV+S0cmtp{3U8afBQJ!ZZ*+*7}h5M`Njwk(aJH9VukoJNaR& z;h@oGTw0fZ6IS|bB~qw}g?)xyyb}JZ`k|&HDTiWp);;MI0ZNC9G9<)c{>L5EWbAXKdPb2SwB{Fs z>!yz*zjAA?uq&XTkZ!LMAB3#KntA9$bqMe|sM`&OMLZSXmKVKVjzurv&qcd=mIIc_ zalck*)k4TC+DVsI3&h>M-j@RlvbZL!Tew(HHe>`GO}|xqh5%ugV^Q^z>O)M5wU7W! z6#Skjq^Yn^Z&7`&xH^g*9)y($aTk(H=B_Mb3(pkg8Yu(B)ha1#S#P-C(LfpKvCg)i zJhIR=w}~Uibu!95Iw*$P~pq(tpUDsh|41oN&> z>6MQYgya=X-E=E6!>;#n5L(PlXW71QZdMz;-hUP)3BP+@za2UR^Lkp^o~um1ixFqO zzwEsIKTTbEIMiSJMq|%5YOGnOu`fe**~u~@`)5CFje}k_$58D2G~>~a(0kbQeXi+}f^mb zRmezHM=PFsu_$b`9?gS|pBP}1VD<3E$k=UC6J z`C=s;?_$x9e}8<$ghJ>@fvNp{1v~Eh>1B{e9hhiEa9-wn2Rk+n@Ztj|La%a3a)9(D z?z*l5O!1kM-(g={%%kwH&upy(zRzyneyy&9boM?Suc@B)yGH*`cI_2qixhJJHDIjG zTGSGpJSKm9HE^C9K=C5#_`q%X=FmYt6<<0;{Gzy4Z9Vik}N`X z?|E+iNXm+YxM++~EW}WNhaO!-7IoYu@qI;{7J6^#Ik>PEh`3youUruo6*U+Nt}l=sue;G? z83}d->Tyj?f%?tst4S|~$-&nO0`(Kk5LfL5kik$O81iMsAJ|OWy-ub^v0U6Y*L;my zI4J>*6wTxLw`6VvxO0y^(;Bihac1?rH}w_*j6n&|#Jy?q6YW`DWU?U6+eh&(>9-2IS=EGh%(|gXZ2Zlvl6AWm&1h>k=Ljwcu}c zXmqQ9;|Q+2oT}M$^=PJTROo!?CTLv!`Zgq^iE}!VUC9DbH#RQz<6INg;Vp0~<#jFd zin_z&dVs+!ZOR;|n6~Hm$g#n7q?iSW<(>+795+yMy9i{M?0z{ra9>QGnPV&NWP#o5 zEduxLwF;-up%_0&KgpR3Fj}vHcw+o?@d9Io=x%*bZz{O$c*1@Am6dcw3>-xVNK7M>&Yt#G#ih@$vc9UE z{2gedM4v&JWhLZ=ki|B-5EBB_pI15~e;s}A2;1de;s_qN-WImIz$R>f{sQz;f00*V zY%gMlJi+Xc#z6Lij0=LYV~=T>dF}9i^LYP7=@*;jaX2>zW*#*+k54t#C2~?mbtS961}tVz z04>1P#U;Sl$6V+g=Ne#saJ$Yi8T+8_Knw|P;LN^m7dOERHI#`13W90e3gY#u4vvm( zK(#;O`*w?uQKqt@TKnFMPmN;Q$;zjND4{_jlrlDJpCpxz(A}D(HKp~}X`~JcXQ3K> z)&d7!tyKNbJwBzA$Kz^mmT(#cE3YseAc)}C9R^`Ne>}lc<=>Ui(ac@3G|qxn<@&>htKcRZ zCv}}{$g~z);Fidp>d}|SKz27xFdNB&GcHZ*KO;ScK+Zy&W5y#d^4))WN%km71+||; z6nN7!xmoIid+kRhoycT}e~l9|OI_w>p>SO7sXl+1-ojt4D8kR1bx*KbEa;;!*rTtY(a)}d^A z?lZI8e0C5nhM}Oc(|l4>40)DH5yr0!kmqFf)_uSwid;Q*c?jjVdj>j@kw9^X7GWX= z*4Re?O$KgWHBK=UNP{%i()$)pJfc`s0Pa5B8P~JAYQ;Xxzn7``l(fA6BQUZ!rrujn z;VbYzhyX?1ZK-o0ib{)sC^{rTF(N|Q!RqDhT_ATgSx{-C`+2v}&85jJw$S}HtB>B; z3x_!Z;et~Q%ndD9D&x1OCk9^}XhfS@m*kgaNKNRQV}(uLSfj zr9%2^Bur%zVXL#AywjJQ_)O~eTOmVv^|`g%s#ISEZEp$)S>FWaq2C=d%C4vVm=cYV zxM2|gaKl>p%;&L3x&|huIT}1EVosv8&|oR#F-KIFM`3DdNOClyUq;`8V8r?U@6p?@ z=a?FL)}*rOT-CViVG$D&PUi1yTSz+xL;m2s8;I0C*|;*RPma{Z?caP4rfun}FBPah z5Gl`Q%j3P+;J_zeBX40EeczQqFFpA)#Y3Axdkd?mUTGQnVBh*)^060G@~-{MR}xBj>Zya5m)i8 z?eOzf4v*EQr5ldi=s$lL%*&w_hUOam$x>gm;xG1oQ2Di_Gs?4&H97jNS53`? zCl;B&IBYcB+PCAn|LdW@&Ut_~!2$HfJ zr%nf=CVbS`MJStTy(^dwSUZlOe>Q{p}ns>I8wL<6|!$or%T-X^D2@Ms@b;WS8CFnMf zVD~v9ic{r09k@-D5qnJ6C==vbFo}UGGg5)@+RF#=%+#{D;z#=(u-mM8maG!2jR$e3 z-?Jv~ioS*3}IPU&)xJTLP&K(Z!NGt-wYvGxP!O!APC(U8N&&&q?{ zLO8#TT7quXD~+Ks_ML07nT3kBA>b5kFNmETAx?&YeR|AF@Y?CS$NumHP4xP@P37G{ z%DKCq{u0-r6H%qODaOF>Q=j-Jm%;4u!5fKnA+v-N;;7|)qnd@>TQP2xp#_p3BywUZ zY&+BqlGCetB27Npm@xf*XrW2e+pfE)g5$o#)(gqEdvn(GP7FXAOQzsxyOF0^FG9J< z`sVH1*PanRVT~j;tLdaGmkX>i8>Hu5#yG`9^MnR}pPEaiZ=;-F<}P4g_SMSe=zcb2 z3+-7Dov(75bJ9|74A!1^dLksFHX($Ui@i}|Ry**+kTd+AGO4Yz^BlXM1OE$flrEtN zzC|&LM@btQ11?`uT4`02{`U-8nxDT35M4U2%Jngm7yy9O!gkCTsd0G@IfdJ~N$O4R zFB`v!l^uPsZi7toOvmX74Yp)$3-fNo*__U+#rhKarSR|!&B0HRZVf{u5(cXcJdEY_ zyOcKDq0(*TFv|oXhVds!^X1jB<~~1{w9e(_Wm%)n#_`zEOH9yG>e@DkyY_58*G?l} zbH*Q`99z;HLO*en9TsW$Q;TSd?cChlf`glDXA$XSZYEH8ecBXox{O^OA>=p3X2ZlE z%kah`g~9xjAx%NwunnhgQo%@0PFjD;$WluvW8l|N4WToNYyWV)`=fN|!Fj6pj_VAZ zT|0h?M1hfvxM710p*noegs-kxHv`^6!qo#=BED)>!!Kffbgb6fHTBF%JQR;ogju$m zli(j5Fb6UbGKzZR-;E9Uk$3OyO>jc&o2rtfGpB@f2D9l}IoGQb{V0))R*muVjZI0l z`RNltu_HoP_jXjGDS$5o<{}Q~kj$se(6;#7ilX{iC|c=y9|aTK^(y172gYu6m(pkt4gic@Z+-1=HbiIWxA`wBdZxb=J|hFx zF_aa+6pSeu(r62;YsMqqTN-q}e_+zsvjtQJ&A5hM5b7PGu*2tH zCFN^FgV^K9j7}gBfWO^es1*1L_`S)ruTiPFC*B0(HPV9<($9i*n1}EQIiZN+uIV*c2>5+2j-W8>B!6`P{c^yN2WY+F`9srMufNY6S064>qOdreL4%}q(k zgA+>DNA|Id$H87QspTzgJxubA4=KBdWimNKo25FC%$olexH0}&)K!0gy#88yj%D>_ zE*=wyC?Mpv2ktqsh|@H&H&bxPp``Zw9+ayn0BqOj`?kIW>o1yu{ROJiuP!z z%d{IrK5#{yF{DPEFLDQ2#FzCo$J!@)lRW!8U@muTgoatb6lGJaWVsA7G z6UYvjAXGDtD_{Vk_`wNomWsLD|DdS2gkv`}!XvL105PjvbQ;@JGB3B@7!bUk11ZXL zYGIYujDN#?7&**G(#!pUqs8KW9sjry7Uoa`6|M#Z`CX6%nojPm$NU^}jsBKZik{vE zfDB#bJOxglj5M&?28kBf5+i~$MD|IyeJG3i7m5#eXlB3VxkPN$);;avD+J=R{7cyd z+#tvc(}y?Fxq9Z0Um6~Gr?mcqh~erYZ=595-(&@}5@9xuPDjc*hr4a7z+YB@xxRO8 zYv+FQF_7{jJAv(c1OFLbwXi4i_gWoNS(gO;RDUT6r&&`_7VVX1~b1{L%v?WFFCb-mx<^9RZGw@vVz< z{l^?#htxBvENjiL08_}nH<2mkXtMN6)k>Pu3Z3p3RBPG3lzC>R4%>IVlWm_A?mmsu zss;%UBWsJJ5WWSu2OIbz=nD^qy{_Bh8J9m6SHVj@k_8UZaS&+!O0hlxub zh9wIW>>%UJZz#fs#PhR^SAVDVfBG7(H(uKX!jkY^WEPUn;>(4jY8abEt--pXl#Y~# zpd-0;^91cDN$>j`_@SnAgn=Y?41ntIz=ZDr$aww)YLoe;rT1t3IY4}QlPNszx-OP( znxD?E84bAbB_(`M+;x1reRR$rvD&71EovS{9+Ms-mE-{5>H*y2A0mlb!3FG2 zct#Z@y39%FpWWSEWp7TALAOEP&&vjB+zDHv!#ZjFntY$X$tK5leSQ9*Dp7tBJi!Gj z29^emmSXho5|qPBXz7oDPmg0_5;cEH&yGk^0uI;71Ag@^%jD5zDX5lW(G+8%I#he- zV^w%0HG&#`0r+l6SSDv`H-1h=kmDiw6&KCE)>yOpm@^Y%sP&*x-D`8~5nP)Lp7!8t z)4LC2L$g)+gV=_sprgYnyN;-P0@^;;D3GvDwK}ARwJy8IR-t$lNiHGf?C^-0(Xmo) z^oSzU+9G>$*-GJy|5WV{y;5paQ5X-2)cHd=3iH(e!GTyrL%^#3&R*F++JbI)`cqoN z;2O4+hv~n=U#x37Rf~Kf{I^B^1bN5d@PsO^Me){u{sATX-*`?D$1ZZYNHsKBlw6@8 z6q7%j=krM)D5pRineG~Mytqmuib9e<=$q^0eSDKr?wCA5e_!NQ^nm!pl>xOk64cu}fvy@LPSV9)F^l4qLloYV4qlOb5nrAmOcYBmvIj8;hpjQX|CJ>Ahz-oq2)!$Vjo z(JG;-4B-fb?ll^Tq<(r!2lqKIt&bIn$#1Eq9qW7lO;)3DQVRz4FXq2kpK*9ip^CJT tmC~9XVZfD-snVEt3+&~qdU)#o=5LP}E_dGG;imvUM*5fap6a0E{|}Bw7r+1j diff --git a/src/heart_flow/Update.md b/src/heart_flow/Update.md new file mode 100644 index 00000000..45a45723 --- /dev/null +++ b/src/heart_flow/Update.md @@ -0,0 +1,11 @@ + +更新： +把聊天控制移动到心流下吧 +首先心流要根据日程以及当前状况判定总体状态MaiStateInfo + +然后根据每个子心流的运行情况，给子心流分配聊天资源（ChatStateInfo：ABSENT CHAT 或者 FOCUS） + +子心流负责根据状态进行执行 + +1.将interest.py进行拆分，class InterestChatting 将会在 sub_heartflow中声明，每个sub_heartflow都会所属一个InterestChatting +class InterestManager 将会在heartflow中声明，成为heartflow的一个组件，伴随heartflow产生 diff --git a/src/heart_flow/ZX65~ALHC_7{Q9FKE$X}TQC.jpg b/src/heart_flow/ZX65~ALHC_7{Q9FKE$X}TQC.jpg deleted file mode 100644 index a2490075dccd761e4e39019515943df0fa7374c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90138 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
  • 7@EjLqlVKF!x!Ke}h^5=1EWzO>dy7l-j$e=&LD| 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�UF2eg7sc9 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 diff --git a/src/heart_flow/heartflow.py b/src/heart_flow/heartflow.py index 50f0a735..f30621b0 100644 --- a/src/heart_flow/heartflow.py +++ b/src/heart_flow/heartflow.py @@ -5,12 +5,16 @@ from src.config.config import global_config from src.plugins.schedule.schedule_generator import bot_schedule from src.plugins.utils.prompt_builder import Prompt, global_prompt_manager import asyncio -from src.common.logger import get_module_logger, LogConfig, HEARTFLOW_STYLE_CONFIG # noqa: E402 +from src.common.logger import get_module_logger, LogConfig, HEARTFLOW_STYLE_CONFIG # 修改 from src.individuality.individuality import Individuality import time import random from typing import Dict, Any, Optional import traceback +import enum +import os # 新增 +import json # 新增 +from src.plugins.chat.chat_stream import chat_manager # 新增 heartflow_config = LogConfig( # 使用海马体专用样式 @@ -41,80 +45,262 @@ def init_prompt(): Prompt(prompt, "mind_summary_prompt") -class CurrentState: +# --- 新增：从 interest.py 移动过来的常量 --- +LOG_DIRECTORY = "logs/interest" +HISTORY_LOG_FILENAME = "interest_history.log" +CLEANUP_INTERVAL_SECONDS = 1200 # 清理任务运行间隔 (例如：20分钟) - 保持与 interest.py 一致 +INACTIVE_THRESHOLD_SECONDS = 1200 # 不活跃时间阈值 (例如：20分钟) - 保持与 interest.py 一致 +LOG_INTERVAL_SECONDS = 3 # 日志记录间隔 (例如：3秒) - 保持与 interest.py 一致 +# --- 结束新增常量 --- + + +# 新增 ChatStatus 枚举 +class MaiState(enum.Enum): + """ + 聊天状态: + OFFLINE: 不在线：回复概率极低，不会进行任何聊天 + PEEKING: 看一眼手机：回复概率较低，会进行一些普通聊天 + NORMAL_CHAT: 正常聊天：回复概率较高，会进行一些普通聊天和少量的专注聊天 + FOCUSED_CHAT: 专注聊天：回复概率极高，会进行专注聊天和少量的普通聊天 + """ + + OFFLINE = "不在线" + PEEKING = "看一眼手机" + NORMAL_CHAT = "正常聊天" + FOCUSED_CHAT = "专注聊天" + + def get_normal_chat_max_num(self): + if self == MaiState.OFFLINE: + return 0 + elif self == MaiState.PEEKING: + return 1 + elif self == MaiState.NORMAL_CHAT: + return 3 + elif self == MaiState.FOCUSED_CHAT: + return 2 + + def get_focused_chat_max_num(self): + if self == MaiState.OFFLINE: + return 0 + elif self == MaiState.PEEKING: + return 0 + elif self == MaiState.NORMAL_CHAT: + return 1 + elif self == MaiState.FOCUSED_CHAT: + return 2 + + +class MaiStateInfo: def __init__(self): self.current_state_info = "" - self.chat_status = "IDLE" + # 使用枚举类型初始化状态，默认为不在线 + self.mai_status: MaiState = MaiState.OFFLINE + + self.normal_chatting = [] + self.focused_chatting = [] self.mood_manager = MoodManager() self.mood = self.mood_manager.get_prompt() - self.attendance_factor = 0 - self.engagement_factor = 0 - def update_current_state_info(self): self.current_state_info = self.mood_manager.get_current_mood() + # 新增更新聊天状态的方法 + def update_mai_status(self, new_status: MaiState): + """更新聊天状态""" + if isinstance(new_status, MaiState): + self.mai_status = new_status + logger.info(f"麦麦状态更新为: {self.mai_status.value}") + else: + logger.warning(f"尝试设置无效的麦麦状态: {new_status}") + class Heartflow: def __init__(self): self.current_mind = "你什么也没想" self.past_mind = [] - self.current_state: CurrentState = CurrentState() + self.current_state: MaiStateInfo = MaiStateInfo() self.llm_model = LLMRequest( model=global_config.llm_heartflow, temperature=0.6, max_tokens=1000, request_type="heart_flow" ) self._subheartflows: Dict[Any, SubHeartflow] = {} - async def _cleanup_inactive_subheartflows(self): - """定期清理不活跃的子心流""" + # --- 新增：日志和清理相关属性 (从 InterestManager 移动) --- + self._history_log_file_path = os.path.join(LOG_DIRECTORY, HISTORY_LOG_FILENAME) + self._ensure_log_directory() # 初始化时确保目录存在 + self._cleanup_task: Optional[asyncio.Task] = None + self._logging_task: Optional[asyncio.Task] = None + # 注意：衰减任务 (_decay_task) 不再需要，衰减在 SubHeartflow 的 InterestChatting 内部处理 + # --- 结束新增属性 --- + + def _ensure_log_directory(self): # 新增方法 (从 InterestManager 移动) + """确保日志目录存在""" + # 移除 try-except 块，根据用户要求 + os.makedirs(LOG_DIRECTORY, exist_ok=True) + logger.info(f"Log directory '{LOG_DIRECTORY}' ensured.") + # except OSError as e: + # logger.error(f"Error creating log directory '{LOG_DIRECTORY}': {e}") + + async def _periodic_cleanup_task( + self, interval_seconds: int, max_age_seconds: int + ): # 新增方法 (从 InterestManager 移动和修改) + """后台清理任务的异步函数""" while True: - current_time = time.time() - inactive_subheartflows_ids = [] # 修改变量名以清晰表示存储的是ID + await asyncio.sleep(interval_seconds) + logger.info(f"[Heartflow] 运行定期清理 (间隔: {interval_seconds}秒)...") + self.cleanup_inactive_subheartflows(max_age_seconds=max_age_seconds) # 调用 Heartflow 自己的清理方法 - # 检查所有子心流 - # 使用 list(self._subheartflows.items()) 避免在迭代时修改字典 - for subheartflow_id, subheartflow in list(self._subheartflows.items()): - if ( - current_time - subheartflow.last_active_time > global_config.sub_heart_flow_stop_time - ): # 10分钟 = 600秒 - logger.info(f"发现不活跃的子心流: {subheartflow_id}, 准备清理。") - # 1. 标记子心流让其后台任务停止 - subheartflow.should_stop = True - # 2. 将ID添加到待清理列表 - inactive_subheartflows_ids.append(subheartflow_id) + async def _periodic_log_task(self, interval_seconds: int): # 新增方法 (从 InterestManager 移动和修改) + """后台日志记录任务的异步函数 (记录所有子心流的兴趣历史数据)""" + while True: + await asyncio.sleep(interval_seconds) + try: + current_timestamp = time.time() + all_interest_states = self.get_all_interest_states() # 获取所有子心流的兴趣状态 - # 清理不活跃的子心流 (从字典中移除) - for subheartflow_id in inactive_subheartflows_ids: - if subheartflow_id in self._subheartflows: - del self._subheartflows[subheartflow_id] - logger.info(f"已从主心流移除子心流: {subheartflow_id}") - else: - logger.warning(f"尝试移除子心流 {subheartflow_id} 时发现其已被移除。") + # 以追加模式打开历史日志文件 + # 移除 try-except IO 块，根据用户要求 + with open(self._history_log_file_path, "a", encoding="utf-8") as f: + count = 0 + # 创建 items 快照以安全迭代 + items_snapshot = list(all_interest_states.items()) + for stream_id, state in items_snapshot: + # 从 chat_manager 获取 group_name + group_name = stream_id # 默认值 + try: + chat_stream = chat_manager.get_stream(stream_id) + if chat_stream and chat_stream.group_info: + group_name = chat_stream.group_info.group_name + elif chat_stream and not chat_stream.group_info: # 处理私聊 + group_name = ( + f"私聊_{chat_stream.user_info.user_nickname}" + if chat_stream.user_info + else stream_id + ) + except Exception: + # 不记录警告，避免刷屏，使用默认 stream_id 即可 + # logger.warning(f"Could not get group name for stream_id {stream_id}: {e}") + pass # 静默处理 - await asyncio.sleep(30) # 每分钟检查一次 + log_entry = { + "timestamp": round(current_timestamp, 2), + "stream_id": stream_id, + "interest_level": state.get("interest_level", 0.0), # 使用 get 获取，提供默认值 + "group_name": group_name, + "reply_probability": state.get("current_reply_probability", 0.0), # 使用 get 获取 + "is_above_threshold": state.get("is_above_threshold", False), # 使用 get 获取 + } + # 将每个条目作为单独的 JSON 行写入 + f.write(json.dumps(log_entry, ensure_ascii=False) + "\n") + count += 1 + # logger.debug(f"[Heartflow] Successfully appended {count} interest history entries to {self._history_log_file_path}") - async def _sub_heartflow_update(self): + # except IOError as e: + # logger.error(f"[Heartflow] Error writing interest history log to {self._history_log_file_path}: {e}") + except Exception as e: # 保留对其他异常的捕获 + logger.error(f"[Heartflow] Unexpected error during periodic history logging: {e}") + logger.error(traceback.format_exc()) # 记录 traceback + + def get_all_interest_states(self) -> Dict[str, Dict]: # 新增方法 + """获取所有活跃子心流的当前兴趣状态""" + states = {} + # 创建副本以避免在迭代时修改字典 + items_snapshot = list(self._subheartflows.items()) + for stream_id, subheartflow in items_snapshot: + try: + # 从 SubHeartflow 获取其 InterestChatting 的状态 + states[stream_id] = subheartflow.get_interest_state() + except Exception as e: + logger.warning(f"[Heartflow] Error getting interest state for subheartflow {stream_id}: {e}") + return states + + def cleanup_inactive_subheartflows(self, max_age_seconds=INACTIVE_THRESHOLD_SECONDS): # 修改此方法以使用兴趣时间 + """ + 清理长时间不活跃的子心流记录 (基于兴趣交互时间) + max_age_seconds: 超过此时间未通过兴趣系统交互的将被清理 + """ + current_time = time.time() + keys_to_remove = [] + _initial_count = len(self._subheartflows) + + # 创建副本以避免在迭代时修改字典 + items_snapshot = list(self._subheartflows.items()) + + for subheartflow_id, subheartflow in items_snapshot: + should_remove = False + reason = "" + # 检查 InterestChatting 的最后交互时间 + last_interaction = subheartflow.interest_chatting.last_interaction_time + if max_age_seconds is not None and (current_time - last_interaction) > max_age_seconds: + should_remove = True + reason = ( + f"interest inactive time ({current_time - last_interaction:.0f}s) > max age ({max_age_seconds}s)" + ) + + if should_remove: + keys_to_remove.append(subheartflow_id) + stream_name = chat_manager.get_stream_name(subheartflow_id) or subheartflow_id # 获取流名称 + logger.debug(f"[Heartflow] Marking stream {stream_name} for removal. Reason: {reason}") + + # 标记子心流让其后台任务停止 (如果其后台任务还在运行) + subheartflow.should_stop = True + + if keys_to_remove: + logger.info(f"[Heartflow] 清理识别到 {len(keys_to_remove)} 个不活跃的流。") + for key in keys_to_remove: + if key in self._subheartflows: + # 尝试取消子心流的后台任务 + task_to_cancel = self._subheartflows[key].task + if task_to_cancel and not task_to_cancel.done(): + task_to_cancel.cancel() + logger.debug(f"[Heartflow] Cancelled background task for subheartflow {key}") + # 从字典中删除 + del self._subheartflows[key] + stream_name = chat_manager.get_stream_name(key) or key # 获取流名称 + logger.debug(f"[Heartflow] 移除了流: {stream_name}") + final_count = len(self._subheartflows) # 直接获取当前长度 + logger.info(f"[Heartflow] 清理完成。移除了 {len(keys_to_remove)} 个流。当前数量: {final_count}") + else: + # logger.info(f"[Heartflow] 清理完成。没有流符合移除条件。当前数量: {initial_count}") # 减少日志噪音 + pass + + async def _sub_heartflow_update(self): # 这个任务目前作用不大，可以考虑移除或赋予新职责 while True: # 检查是否存在子心流 if not self._subheartflows: # logger.info("当前没有子心流，等待新的子心流创建...") - await asyncio.sleep(30) # 每分钟检查一次是否有新的子心流 + await asyncio.sleep(30) # 短暂休眠 continue - # await self.do_a_thinking() - # await asyncio.sleep(global_config.heart_flow_update_interval * 3) # 5分钟思考一次 - + # 当前无实际操作，只是等待 await asyncio.sleep(300) async def heartflow_start_working(self): - # 启动清理任务 - asyncio.create_task(self._cleanup_inactive_subheartflows()) + # 启动清理任务 (使用新的 periodic_cleanup_task) + if self._cleanup_task is None or self._cleanup_task.done(): + self._cleanup_task = asyncio.create_task( + self._periodic_cleanup_task( + interval_seconds=CLEANUP_INTERVAL_SECONDS, + max_age_seconds=INACTIVE_THRESHOLD_SECONDS, + ) + ) + logger.info( + f"[Heartflow] 已创建定期清理任务。间隔: {CLEANUP_INTERVAL_SECONDS}s, 不活跃阈值: {INACTIVE_THRESHOLD_SECONDS}s" + ) + else: + logger.warning("[Heartflow] 跳过创建清理任务: 任务已在运行或存在。") - # 启动子心流更新任务 - asyncio.create_task(self._sub_heartflow_update()) + # 启动日志任务 (使用新的 periodic_log_task) + if self._logging_task is None or self._logging_task.done(): + self._logging_task = asyncio.create_task(self._periodic_log_task(interval_seconds=LOG_INTERVAL_SECONDS)) + logger.info(f"[Heartflow] 已创建定期日志任务。间隔: {LOG_INTERVAL_SECONDS}s") + else: + logger.warning("[Heartflow] 跳过创建日志任务: 任务已在运行或存在。") + + # (可选) 启动旧的子心流更新任务，如果它还有用的话 + # asyncio.create_task(self._sub_heartflow_update()) @staticmethod async def _update_current_state(): @@ -133,146 +319,149 @@ class Heartflow: prompt_personality += personality_core personality_sides = individuality.personality.personality_sides - random.shuffle(personality_sides) - prompt_personality += f",{personality_sides[0]}" + # 检查列表是否为空 + if personality_sides: + random.shuffle(personality_sides) + prompt_personality += f",{personality_sides[0]}" identity_detail = individuality.identity.identity_detail - random.shuffle(identity_detail) - prompt_personality += f",{identity_detail[0]}" + # 检查列表是否为空 + if identity_detail: + random.shuffle(identity_detail) + prompt_personality += f",{identity_detail[0]}" personality_info = prompt_personality current_thinking_info = self.current_mind mood_info = self.current_state.mood - related_memory_info = "memory" + related_memory_info = "memory" # TODO: 替换为实际的记忆获取逻辑 try: - sub_flows_info = await self.get_all_subheartflows_minds() + sub_flows_info = await self.get_all_subheartflows_minds_summary() # 修改为调用汇总方法 except Exception as e: - logger.error(f"获取子心流的想法失败: {e}") - return + logger.error(f"[Heartflow] 获取子心流想法汇总失败: {e}") + logger.error(traceback.format_exc()) + sub_flows_info = "(获取子心流想法时出错)" # 提供默认值 schedule_info = bot_schedule.get_current_num_task(num=4, time_info=True) - # prompt = "" - # prompt += f"你刚刚在做的事情是：{schedule_info}\n" - # prompt += f"{personality_info}\n" - # prompt += f"你想起来{related_memory_info}。" - # prompt += f"刚刚你的主要想法是{current_thinking_info}。" - # prompt += f"你还有一些小想法，因为你在参加不同的群聊天，这是你正在做的事情：{sub_flows_info}\n" - # prompt += f"你现在{mood_info}。" - # prompt += "现在你接下去继续思考，产生新的想法，但是要基于原有的主要想法，不要分点输出，" - # prompt += "输出连贯的内心独白，不要太长，但是记得结合上述的消息，关注新内容:" prompt = (await global_prompt_manager.get_prompt_async("thinking_prompt")).format( - schedule_info, personality_info, related_memory_info, current_thinking_info, sub_flows_info, mood_info + schedule_info=schedule_info, # 使用关键字参数确保正确格式化 + personality_info=personality_info, + related_memory_info=related_memory_info, + current_thinking_info=current_thinking_info, + sub_flows_info=sub_flows_info, + mood_info=mood_info, ) try: response, reasoning_content = await self.llm_model.generate_response_async(prompt) + if not response: + logger.warning("[Heartflow] 内心独白 LLM 返回空结果。") + response = "(暂时没什么想法...)" # 提供默认想法 + + self.update_current_mind(response) # 更新主心流想法 + logger.info(f"麦麦的总体脑内状态：{self.current_mind}") + + # 更新所有子心流的主心流信息 + items_snapshot = list(self._subheartflows.items()) # 创建快照 + for _, subheartflow in items_snapshot: + subheartflow.main_heartflow_info = response + except Exception as e: - logger.error(f"内心独白获取失败: {e}") - return - self.update_current_mind(response) - - self.current_mind = response - logger.info(f"麦麦的总体脑内状态：{self.current_mind}") - # logger.info("麦麦想了想，当前活动:") - # await bot_schedule.move_doing(self.current_mind) - - for _, subheartflow in self._subheartflows.items(): - subheartflow.main_heartflow_info = response + logger.error(f"[Heartflow] 内心独白获取失败: {e}") + logger.error(traceback.format_exc()) + # 此处不返回，允许程序继续执行，但主心流想法未更新 def update_current_mind(self, response): self.past_mind.append(self.current_mind) self.current_mind = response - async def get_all_subheartflows_minds(self): - sub_minds = "" - for _, subheartflow in self._subheartflows.items(): - sub_minds += subheartflow.current_mind + async def get_all_subheartflows_minds_summary(self): # 重命名并修改 + """获取所有子心流的当前想法，并进行汇总""" + sub_minds_list = [] + # 创建快照 + items_snapshot = list(self._subheartflows.items()) + for _, subheartflow in items_snapshot: + sub_minds_list.append(subheartflow.current_mind) - return await self.minds_summary(sub_minds) + if not sub_minds_list: + return "(当前没有活跃的子心流想法)" + + minds_str = "\n".join([f"- {mind}" for mind in sub_minds_list]) # 格式化为列表 + + # 调用 LLM 进行汇总 + return await self.minds_summary(minds_str) async def minds_summary(self, minds_str): + """使用 LLM 汇总子心流的想法字符串""" # 开始构建prompt prompt_personality = "你" - # person individuality = Individuality.get_instance() - - personality_core = individuality.personality.personality_core - prompt_personality += personality_core - - personality_sides = individuality.personality.personality_sides - random.shuffle(personality_sides) - prompt_personality += f",{personality_sides[0]}" - - identity_detail = individuality.identity.identity_detail - random.shuffle(identity_detail) - prompt_personality += f",{identity_detail[0]}" + prompt_personality += individuality.personality.personality_core + if individuality.personality.personality_sides: + prompt_personality += f",{random.choice(individuality.personality.personality_sides)}" # 随机选一个 + if individuality.identity.identity_detail: + prompt_personality += f",{random.choice(individuality.identity.identity_detail)}" # 随机选一个 personality_info = prompt_personality mood_info = self.current_state.mood + bot_name = global_config.BOT_NICKNAME # 使用全局配置中的机器人昵称 - # prompt = "" - # prompt += f"{personality_info}\n" - # prompt += f"现在{global_config.BOT_NICKNAME}的想法是：{self.current_mind}\n" - # prompt += f"现在{global_config.BOT_NICKNAME}在qq群里进行聊天，聊天的话题如下：{minds_str}\n" - # prompt += f"你现在{mood_info}\n" - # prompt += """现在请你总结这些聊天内容，注意关注聊天内容对原有的想法的影响，输出连贯的内心独白 - # 不要太长，但是记得结合上述的消息，要记得你的人设，关注新内容:""" prompt = (await global_prompt_manager.get_prompt_async("mind_summary_prompt")).format( - personality_info, global_config.BOT_NICKNAME, self.current_mind, minds_str, mood_info + personality_info=personality_info, # 使用关键字参数 + bot_name=bot_name, + current_mind=self.current_mind, + minds_str=minds_str, + mood_info=mood_info, ) - response, reasoning_content = await self.llm_model.generate_response_async(prompt) - - return response + try: + response, reasoning_content = await self.llm_model.generate_response_async(prompt) + if not response: + logger.warning("[Heartflow] 想法汇总 LLM 返回空结果。") + return "(想法汇总失败...)" + return response + except Exception as e: + logger.error(f"[Heartflow] 想法汇总失败: {e}") + logger.error(traceback.format_exc()) + return "(想法汇总时发生错误...)" async def create_subheartflow(self, subheartflow_id: Any) -> Optional[SubHeartflow]: """ 获取或创建一个新的SubHeartflow实例。 - - 如果实例已存在，则直接返回。 - 如果不存在，则创建实例、观察对象、启动后台任务，并返回新实例。 - 创建过程中发生任何错误将返回 None。 - - Args: - subheartflow_id: 用于标识子心流的ID (例如群聊ID)。 - - Returns: - 对应的 SubHeartflow 实例，如果创建失败则返回 None。 + (主要逻辑不变，InterestChatting 现在在 SubHeartflow 内部创建) """ - # 检查是否已存在 existing_subheartflow = self._subheartflows.get(subheartflow_id) if existing_subheartflow: - logger.debug(f"返回已存在的 subheartflow: {subheartflow_id}") + # 如果已存在，确保其 last_active_time 更新 (如果需要的话) + # existing_subheartflow.last_active_time = time.time() # 移除，活跃时间由实际操作更新 + # logger.debug(f"[Heartflow] 返回已存在的 subheartflow: {subheartflow_id}") return existing_subheartflow - # 如果不存在，则创建新的 - logger.info(f"尝试创建新的 subheartflow: {subheartflow_id}") + logger.info(f"[Heartflow] 尝试创建新的 subheartflow: {subheartflow_id}") try: + # 创建 SubHeartflow，它内部会创建 InterestChatting subheartflow = SubHeartflow(subheartflow_id) # 创建并初始化观察对象 - logger.debug(f"为 {subheartflow_id} 创建 observation") + logger.debug(f"[Heartflow] 为 {subheartflow_id} 创建 observation") observation = ChattingObservation(subheartflow_id) - await observation.initialize() # 等待初始化完成 + await observation.initialize() subheartflow.add_observation(observation) - logger.debug(f"为 {subheartflow_id} 添加 observation 成功") + logger.debug(f"[Heartflow] 为 {subheartflow_id} 添加 observation 成功") - # 创建并存储后台任务 + # 创建并存储后台任务 (SubHeartflow 自己的后台任务) subheartflow.task = asyncio.create_task(subheartflow.subheartflow_start_working()) - logger.debug(f"为 {subheartflow_id} 创建后台任务成功") + logger.debug(f"[Heartflow] 为 {subheartflow_id} 创建后台任务成功") # 添加到管理字典 self._subheartflows[subheartflow_id] = subheartflow - logger.info(f"添加 subheartflow {subheartflow_id} 成功") + logger.info(f"[Heartflow] 添加 subheartflow {subheartflow_id} 成功") return subheartflow except Exception as e: - # 记录详细错误信息 - logger.error(f"创建 subheartflow {subheartflow_id} 失败: {e}") - logger.error(traceback.format_exc()) # 记录完整的 traceback - # 考虑是否需要更具体的错误处理或资源清理逻辑 + logger.error(f"[Heartflow] 创建 subheartflow {subheartflow_id} 失败: {e}") + logger.error(traceback.format_exc()) return None def get_subheartflow(self, observe_chat_id: Any) -> Optional[SubHeartflow]: diff --git a/src/heart_flow/sub_heartflow.py b/src/heart_flow/sub_heartflow.py index 9087b576..584d24f2 100644 --- a/src/heart_flow/sub_heartflow.py +++ b/src/heart_flow/sub_heartflow.py @@ -4,21 +4,20 @@ from src.plugins.moods.moods import MoodManager from src.plugins.models.utils_model import LLMRequest from src.config.config import global_config import time -from typing import Optional, List +from typing import Optional, List, Dict import traceback from src.plugins.chat.utils import parse_text_timestamps - -# from src.plugins.schedule.schedule_generator import bot_schedule -# from src.plugins.memory_system.Hippocampus import HippocampusManager +import enum from src.common.logger import get_module_logger, LogConfig, SUB_HEARTFLOW_STYLE_CONFIG # noqa: E402 - -# from src.plugins.chat.utils import get_embedding -# from src.common.database import db -# from typing import Union from src.individuality.individuality import Individuality import random from src.plugins.person_info.relationship_manager import relationship_manager from ..plugins.utils.prompt_builder import Prompt, global_prompt_manager +from src.plugins.chat.message import MessageRecv +import math + +# 定义常量 (从 interest.py 移动过来) +MAX_INTEREST = 15.0 subheartflow_config = LogConfig( # 使用海马体专用样式 @@ -27,6 +26,12 @@ subheartflow_config = LogConfig( ) logger = get_module_logger("subheartflow", config=subheartflow_config) +interest_log_config = LogConfig( + console_format=SUB_HEARTFLOW_STYLE_CONFIG["console_format"], + file_format=SUB_HEARTFLOW_STYLE_CONFIG["file_format"], +) +interest_logger = get_module_logger("InterestChatting", config=interest_log_config) + def init_prompt(): prompt = "" @@ -48,16 +53,166 @@ def init_prompt(): Prompt(prompt, "sub_heartflow_prompt_before") -class CurrentState: +class ChatState(enum.Enum): + ABSENT = "不参与" + CHAT = "闲聊" + FOCUSED = "专注" + + +class ChatStateInfo: def __init__(self): self.willing = 0 - self.current_state_info = "" + + self.chat_status: ChatState = ChatState.ABSENT self.mood_manager = MoodManager() self.mood = self.mood_manager.get_prompt() - def update_current_state_info(self): - self.current_state_info = self.mood_manager.get_current_mood() + def update_chat_state_info(self): + self.chat_state_info = self.mood_manager.get_current_mood() + + +base_reply_probability = 0.05 +probability_increase_rate_per_second = 0.08 +max_reply_probability = 1 + + +class InterestChatting: + def __init__( + self, + decay_rate=global_config.default_decay_rate_per_second, + max_interest=MAX_INTEREST, + trigger_threshold=global_config.reply_trigger_threshold, + base_reply_probability=base_reply_probability, + increase_rate=probability_increase_rate_per_second, + decay_factor=global_config.probability_decay_factor_per_second, + max_probability=max_reply_probability, + ): + self.interest_level: float = 0.0 + self.last_update_time: float = time.time() + self.decay_rate_per_second: float = decay_rate + self.max_interest: float = max_interest + self.last_interaction_time: float = self.last_update_time + + self.trigger_threshold: float = trigger_threshold + self.base_reply_probability: float = base_reply_probability + self.probability_increase_rate: float = increase_rate + self.probability_decay_factor: float = decay_factor + self.max_reply_probability: float = max_probability + self.current_reply_probability: float = 0.0 + self.is_above_threshold: bool = False + + self.interest_dict: Dict[str, tuple[MessageRecv, float, bool]] = {} + + def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool): + self.interest_dict[message.message_info.message_id] = (message, interest_value, is_mentioned) + self.last_interaction_time = time.time() + + def _calculate_decay(self, current_time: float): + time_delta = current_time - self.last_update_time + if time_delta > 0: + old_interest = self.interest_level + if self.interest_level < 1e-9: + self.interest_level = 0.0 + else: + if self.decay_rate_per_second <= 0: + interest_logger.warning( + f"InterestChatting encountered non-positive decay rate: {self.decay_rate_per_second}. Setting interest to 0." + ) + self.interest_level = 0.0 + elif self.interest_level < 0: + interest_logger.warning( + f"InterestChatting encountered negative interest level: {self.interest_level}. Setting interest to 0." + ) + self.interest_level = 0.0 + else: + try: + decay_factor = math.pow(self.decay_rate_per_second, time_delta) + self.interest_level *= decay_factor + except ValueError as e: + interest_logger.error( + f"Math error during decay calculation: {e}. Rate: {self.decay_rate_per_second}, Delta: {time_delta}, Level: {self.interest_level}. Setting interest to 0." + ) + self.interest_level = 0.0 + + if old_interest != self.interest_level: + self.last_update_time = current_time + + def _update_reply_probability(self, current_time: float): + time_delta = current_time - self.last_update_time + if time_delta <= 0: + return + + currently_above = self.interest_level >= self.trigger_threshold + + if currently_above: + if not self.is_above_threshold: + self.current_reply_probability = self.base_reply_probability + interest_logger.debug( + f"兴趣跨过阈值 ({self.trigger_threshold}). 概率重置为基础值: {self.base_reply_probability:.4f}" + ) + else: + increase_amount = self.probability_increase_rate * time_delta + self.current_reply_probability += increase_amount + + self.current_reply_probability = min(self.current_reply_probability, self.max_reply_probability) + + else: + if 0 < self.probability_decay_factor < 1: + decay_multiplier = math.pow(self.probability_decay_factor, time_delta) + self.current_reply_probability *= decay_multiplier + if self.current_reply_probability < 1e-6: + self.current_reply_probability = 0.0 + elif self.probability_decay_factor <= 0: + if self.current_reply_probability > 0: + interest_logger.warning(f"无效的衰减因子 ({self.probability_decay_factor}). 设置概率为0.") + self.current_reply_probability = 0.0 + + self.current_reply_probability = max(self.current_reply_probability, 0.0) + + self.is_above_threshold = currently_above + + def increase_interest(self, current_time: float, value: float): + self._update_reply_probability(current_time) + self._calculate_decay(current_time) + self.interest_level += value + self.interest_level = min(self.interest_level, self.max_interest) + self.last_update_time = current_time + self.last_interaction_time = current_time + + def decrease_interest(self, current_time: float, value: float): + self._update_reply_probability(current_time) + self.interest_level -= value + self.interest_level = max(self.interest_level, 0.0) + self.last_update_time = current_time + self.last_interaction_time = current_time + + def get_interest(self) -> float: + current_time = time.time() + self._update_reply_probability(current_time) + self._calculate_decay(current_time) + self.last_update_time = current_time + return self.interest_level + + def get_state(self) -> dict: + interest = self.get_interest() + return { + "interest_level": round(interest, 2), + "last_update_time": self.last_update_time, + "current_reply_probability": round(self.current_reply_probability, 4), + "is_above_threshold": self.is_above_threshold, + "last_interaction_time": self.last_interaction_time, + } + + def should_evaluate_reply(self) -> bool: + current_time = time.time() + self._update_reply_probability(current_time) + + if self.current_reply_probability > 0: + trigger = random.random() < self.current_reply_probability + return trigger + else: + return False class SubHeartflow: @@ -66,7 +221,10 @@ class SubHeartflow: self.current_mind = "你什么也没想" self.past_mind = [] - self.current_state: CurrentState = CurrentState() + self.chat_state: ChatStateInfo = ChatStateInfo() + + self.interest_chatting = InterestChatting() + self.llm_model = LLMRequest( model=global_config.llm_sub_heartflow, temperature=global_config.llm_sub_heartflow["temp"], @@ -123,7 +281,7 @@ class SubHeartflow: self.last_active_time = time.time() # 更新最后激活时间戳 current_thinking_info = self.current_mind - mood_info = self.current_state.mood + mood_info = self.chat_state.mood observation = self._get_primary_observation() # --- 获取观察信息 --- # @@ -255,6 +413,26 @@ class SubHeartflow: logger.warning(f"SubHeartflow {self.subheartflow_id} 没有找到有效的 ChattingObservation") return None + def get_interest_state(self) -> dict: + """获取当前兴趣状态""" + return self.interest_chatting.get_state() + + def get_interest_level(self) -> float: + """获取当前兴趣等级""" + return self.interest_chatting.get_interest() + + def should_evaluate_reply(self) -> bool: + """判断是否应该评估回复""" + return self.interest_chatting.should_evaluate_reply() + + def add_interest_dict_entry(self, message: MessageRecv, interest_value: float, is_mentioned: bool): + """添加兴趣字典条目""" + self.interest_chatting.add_interest_dict(message, interest_value, is_mentioned) + + def get_interest_dict(self) -> Dict[str, tuple[MessageRecv, float, bool]]: + """获取兴趣字典""" + return self.interest_chatting.interest_dict + init_prompt() # subheartflow = SubHeartflow() diff --git a/src/main.py b/src/main.py index 99578591..8e4d966c 100644 --- a/src/main.py +++ b/src/main.py @@ -17,7 +17,6 @@ from .common.logger import get_module_logger from .plugins.remote import heartbeat_thread # noqa: F401 from .individuality.individuality import Individuality from .common.server import global_server -from .plugins.chat_module.heartFC_chat.interest import InterestManager from .plugins.chat_module.heartFC_chat.heartFC_controler import HeartFCController logger = get_module_logger("main") @@ -112,11 +111,6 @@ class MainSystem: asyncio.create_task(heartflow.heartflow_start_working()) logger.success("心流系统启动成功") - # 启动 InterestManager 的后台任务 - interest_manager = InterestManager() # 获取单例 - await interest_manager.start_background_tasks() - logger.success("兴趣管理器后台任务启动成功") - # 初始化并独立启动 HeartFCController HeartFCController() heartfc_chat_instance = HeartFCController.get_instance() diff --git a/src/plugins/chat/bot.py b/src/plugins/chat/bot.py index 12ee7b6d..05a0bcff 100644 --- a/src/plugins/chat/bot.py +++ b/src/plugins/chat/bot.py @@ -27,7 +27,6 @@ class ChatBot: self.bot = None # bot 实例引用 self._started = False self.mood_manager = MoodManager.get_instance() # 获取情绪管理器单例 - self.mood_manager.start_mood_update() # 启动情绪更新 self.reasoning_chat = ReasoningChat() self.heartFC_processor = HeartFCProcessor() # 新增 diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py index 4dd49e2d..cd33221f 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_controler.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_controler.py @@ -7,10 +7,10 @@ from ...chat.emoji_manager import emoji_manager from .heartFC_generator import ResponseGenerator from .messagesender import MessageManager from src.heart_flow.heartflow import heartflow +from src.heart_flow.sub_heartflow import SubHeartflow, ChatState from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig from src.plugins.person_info.relationship_manager import relationship_manager from src.do_tool.tool_use import ToolUser -from .interest import InterestManager from src.plugins.chat.chat_stream import chat_manager from .pf_chatting import PFChatting @@ -46,34 +46,22 @@ class HeartFCController: # 使用 _initialized 标志确保 __init__ 只执行一次 if self._initialized: return - # 虽然 __new__ 保证了只有一个实例，但为了防止意外重入或多线程下的初始化竞争， - # 再次使用类锁保护初始化过程是更严谨的做法。 - # 如果确定 __init__ 逻辑本身是幂等的或非关键的，可以省略这里的锁。 - # 但为了保持原始逻辑的意图（防止重复初始化），这里保留检查。 - with self.__class__._lock: # 确保初始化逻辑线程安全 - if self._initialized: # 再次检查，防止锁等待期间其他线程已完成初始化 - return - logger.info("正在初始化 HeartFCController 单例...") - self.gpt = ResponseGenerator() - self.mood_manager = MoodManager.get_instance() - # 注意：mood_manager 的 start_mood_update 可能需要在应用主循环启动后调用， - # 或者确保其内部实现是安全的。这里保持原状。 - self.mood_manager.start_mood_update() - self.tool_user = ToolUser() - # 注意：InterestManager() 可能是另一个单例或需要特定初始化。 - # 假设 InterestManager() 返回的是正确配置的实例。 - self.interest_manager = InterestManager() - self._interest_monitor_task: Optional[asyncio.Task] = None - self.pf_chatting_instances: Dict[str, PFChatting] = {} - # _pf_chatting_lock 用于保护 pf_chatting_instances 的异步操作 - self._pf_chatting_lock = asyncio.Lock() # 这个是 asyncio.Lock，用于异步上下文 - self.emoji_manager = emoji_manager # 假设是全局或已初始化的实例 - self.relationship_manager = relationship_manager # 假设是全局或已初始化的实例 - # MessageManager 可能是类本身或单例实例，根据其设计确定 - self.MessageManager = MessageManager - self._initialized = True - logger.info("HeartFCController 单例初始化完成。") + self.gpt = ResponseGenerator() + self.mood_manager = MoodManager.get_instance() + self.tool_user = ToolUser() + self._interest_monitor_task: Optional[asyncio.Task] = None + + self.heartflow = heartflow + + self.pf_chatting_instances: Dict[str, PFChatting] = {} + self._pf_chatting_lock = asyncio.Lock() # 这个是 asyncio.Lock，用于异步上下文 + self.emoji_manager = emoji_manager # 假设是全局或已初始化的实例 + self.relationship_manager = relationship_manager # 假设是全局或已初始化的实例 + + self.MessageManager = MessageManager + self._initialized = True + logger.info("HeartFCController 单例初始化完成。") @classmethod def get_instance(cls): @@ -114,7 +102,7 @@ class HeartFCController: if self._interest_monitor_task is None or self._interest_monitor_task.done(): try: loop = asyncio.get_running_loop() - self._interest_monitor_task = loop.create_task(self._interest_monitor_loop()) + self._interest_monitor_task = loop.create_task(self._response_control_loop()) except RuntimeError: logger.error("创建兴趣监控任务失败：没有运行中的事件循环。") raise @@ -138,41 +126,41 @@ class HeartFCController: # --- End Added PFChatting Instance Manager --- - async def _interest_monitor_loop(self): + # async def update_mai_Status(self): + # """后台任务，定期检查更新麦麦状态""" + # logger.info("麦麦状态更新循环开始...") + # while True: + # await asyncio.sleep(0) + # self.heartflow.update_chat_status() + + async def _response_control_loop(self): """后台任务，定期检查兴趣度变化并触发回复""" logger.info("兴趣监控循环开始...") while True: await asyncio.sleep(INTEREST_MONITOR_INTERVAL_SECONDS) + try: # 从心流中获取活跃流 - active_stream_ids = list(heartflow.get_all_subheartflows_streams_ids()) + active_stream_ids = list(self.heartflow.get_all_subheartflows_streams_ids()) for stream_id in active_stream_ids: stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 - sub_hf = heartflow.get_subheartflow(stream_id) + sub_hf = self.heartflow.get_subheartflow(stream_id) if not sub_hf: logger.warning(f"监控循环: 无法获取活跃流 {stream_name} 的 sub_hf") continue - should_trigger = False + should_trigger_hfc = False try: - interest_chatting = self.interest_manager.get_interest_chatting(stream_id) - if interest_chatting: - should_trigger = interest_chatting.should_evaluate_reply() - else: - logger.trace( - f"[{stream_name}] 没有找到对应的 InterestChatting 实例，跳过基于兴趣的触发检查。" - ) + interest_chatting = sub_hf.interest_chatting + should_trigger_hfc = interest_chatting.should_evaluate_reply() + except Exception as e: logger.error(f"检查兴趣触发器时出错 流 {stream_name}: {e}") logger.error(traceback.format_exc()) - if should_trigger: + if should_trigger_hfc: # 启动一次麦麦聊天 - pf_instance = await self._get_or_create_pf_chatting(stream_id) - if pf_instance: - asyncio.create_task(pf_instance.add_time()) - else: - logger.error(f"[{stream_name}] 无法获取或创建PFChatting实例。跳过触发。") + await self._trigger_hfc(sub_hf) except asyncio.CancelledError: logger.info("兴趣监控循环已取消。") @@ -181,3 +169,17 @@ class HeartFCController: logger.error(f"兴趣监控循环错误: {e}") logger.error(traceback.format_exc()) await asyncio.sleep(5) # 发生错误时等待 + + async def _trigger_hfc(self, sub_hf: SubHeartflow): + chat_state = sub_hf.chat_state + if chat_state == ChatState.ABSENT: + chat_state = ChatState.CHAT + elif chat_state == ChatState.CHAT: + chat_state = ChatState.FOCUSED + + # 从 sub_hf 获取 stream_id + if chat_state == ChatState.FOCUSED: + stream_id = sub_hf.subheartflow_id + pf_instance = await self._get_or_create_pf_chatting(stream_id) + if pf_instance: # 确保实例成功获取或创建 + asyncio.create_task(pf_instance.add_time()) diff --git a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py index f907a8be..00a9a024 100644 --- a/src/plugins/chat_module/heartFC_chat/heartFC_processor.py +++ b/src/plugins/chat_module/heartFC_chat/heartFC_processor.py @@ -11,7 +11,6 @@ from src.common.logger import get_module_logger, CHAT_STYLE_CONFIG, LogConfig from ...chat.chat_stream import chat_manager from ...chat.message_buffer import message_buffer from ...utils.timer_calculater import Timer -from .interest import InterestManager from src.plugins.person_info.relationship_manager import relationship_manager from .reasoning_chat import ReasoningChat @@ -22,14 +21,10 @@ processor_config = LogConfig( ) logger = get_module_logger("heartFC_processor", config=processor_config) -# # 定义兴趣度增加触发回复的阈值 (移至 InterestManager) -# INTEREST_INCREASE_THRESHOLD = 0.5 - class HeartFCProcessor: def __init__(self): self.storage = MessageStorage() - self.interest_manager = InterestManager() self.reasoning_chat = ReasoningChat.get_instance() async def process_message(self, message_data: str) -> None: @@ -74,9 +69,15 @@ class HeartFCProcessor: group_info=groupinfo, ) - # --- 添加兴趣追踪启动 --- - # 在获取到 chat 对象后，启动对该聊天流的兴趣监控 - await self.reasoning_chat.start_monitoring_interest(chat) + # --- 确保 SubHeartflow 存在 --- + subheartflow = await heartflow.create_subheartflow(chat.stream_id) + if not subheartflow: + logger.error(f"无法为 stream_id {chat.stream_id} 创建或获取 SubHeartflow，中止处理") + return + + # --- 添加兴趣追踪启动 (现在移动到这里，确保 subheartflow 存在后启动) --- + # 在获取到 chat 对象和确认 subheartflow 后，启动对该聊天流的兴趣监控 + await self.reasoning_chat.start_monitoring_interest(chat) # start_monitoring_interest 内部需要修改以适应 # --- 结束添加 --- message.update_chat_stream(chat) @@ -141,23 +142,35 @@ class HeartFCProcessor: logger.error(f"计算记忆激活率失败: {e}") logger.error(traceback.format_exc()) + # --- 修改：兴趣度更新逻辑 --- # if is_mentioned: - interested_rate += 0.8 + interest_increase_on_mention = 2 + mentioned_boost = interest_increase_on_mention # 从配置获取提及增加值 + interested_rate += mentioned_boost + logger.trace(f"消息提及机器人，额外增加兴趣 {mentioned_boost:.2f}") - # 更新兴趣度 + # 更新兴趣度 (调用 SubHeartflow 的方法) + current_interest = 0.0 # 初始化 try: - self.interest_manager.increase_interest(chat.stream_id, value=interested_rate) - current_interest = self.interest_manager.get_interest(chat.stream_id) # 获取更新后的值用于日志 + # 获取当前时间，传递给 increase_interest + current_time = time.time() + subheartflow.interest_chatting.increase_interest(current_time, value=interested_rate) + current_interest = subheartflow.get_interest_level() # 获取更新后的值 + logger.trace( - f"使用激活率 {interested_rate:.2f} 更新后 (通过缓冲后)，当前兴趣度: {current_interest:.2f}" + f"使用激活率 {interested_rate:.2f} 更新后 (通过缓冲后)，当前兴趣度: {current_interest:.2f} (Stream: {chat.stream_id})" ) - self.interest_manager.add_interest_dict(message, interested_rate, is_mentioned) + # 添加到 SubHeartflow 的 interest_dict + subheartflow.add_interest_dict_entry(message, interested_rate, is_mentioned) + logger.trace( + f"Message {message.message_info.message_id} added to interest dict for stream {chat.stream_id}" + ) except Exception as e: - logger.error(f"更新兴趣度失败: {e}") # 调整日志消息 + logger.error(f"更新兴趣度失败 (Stream: {chat.stream_id}): {e}") logger.error(traceback.format_exc()) - # ---- 兴趣度计算和更新结束 ---- + # --- 结束修改 --- # # 打印消息接收和处理信息 mes_name = chat.group_info.group_name if chat.group_info else "私聊" diff --git a/src/plugins/chat_module/heartFC_chat/interest.py b/src/plugins/chat_module/heartFC_chat/interest.py deleted file mode 100644 index 4ac5498a..00000000 --- a/src/plugins/chat_module/heartFC_chat/interest.py +++ /dev/null @@ -1,503 +0,0 @@ -import time -import math -import asyncio -import threading -import json # 引入 json -import os # 引入 os -from typing import Optional # <--- 添加导入 -import random # <--- 添加导入 random -from src.plugins.chat.message import MessageRecv -from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG -from src.plugins.chat.chat_stream import chat_manager # *** Import ChatManager *** - -# 定义日志配置 (使用 loguru 格式) -interest_log_config = LogConfig( - console_format=DEFAULT_CONFIG["console_format"], # 使用默认控制台格式 - file_format=DEFAULT_CONFIG["file_format"], # 使用默认文件格式 -) -logger = get_module_logger("InterestManager", config=interest_log_config) - - -# 定义常量 -DEFAULT_DECAY_RATE_PER_SECOND = 0.98 # 每秒衰减率 (兴趣保留 99%) -MAX_INTEREST = 15.0 # 最大兴趣值 -# MIN_INTEREST_THRESHOLD = 0.1 # 低于此值可能被清理 (可选) -CLEANUP_INTERVAL_SECONDS = 1200 # 清理任务运行间隔 (例如：20分钟) -INACTIVE_THRESHOLD_SECONDS = 1200 # 不活跃时间阈值 (例如：20分钟) -LOG_INTERVAL_SECONDS = 3 # 日志记录间隔 (例如：30秒) -LOG_DIRECTORY = "logs/interest" # 日志目录 -# LOG_FILENAME = "interest_log.json" # 快照日志文件名 (保留，以防其他地方用到) -HISTORY_LOG_FILENAME = "interest_history.log" # 新的历史日志文件名 -# 移除阈值，将移至 HeartFC_Chat -# INTEREST_INCREASE_THRESHOLD = 0.5 - -# --- 新增：概率回复相关常量 --- -REPLY_TRIGGER_THRESHOLD = 3.0 # 触发概率回复的兴趣阈值 (示例值) -BASE_REPLY_PROBABILITY = 0.1 # 首次超过阈值时的基础回复概率 (示例值) -PROBABILITY_INCREASE_RATE_PER_SECOND = 0.02 # 高于阈值时，每秒概率增加量 (线性增长, 示例值) -PROBABILITY_DECAY_FACTOR_PER_SECOND = 0.2 # 低于阈值时，每秒概率衰减因子 (指数衰减, 示例值) -MAX_REPLY_PROBABILITY = 1 # 回复概率上限 (示例值) -# --- 结束：概率回复相关常量 --- - - -class InterestChatting: - def __init__( - self, - decay_rate=DEFAULT_DECAY_RATE_PER_SECOND, - max_interest=MAX_INTEREST, - trigger_threshold=REPLY_TRIGGER_THRESHOLD, - base_reply_probability=BASE_REPLY_PROBABILITY, - increase_rate=PROBABILITY_INCREASE_RATE_PER_SECOND, - decay_factor=PROBABILITY_DECAY_FACTOR_PER_SECOND, - max_probability=MAX_REPLY_PROBABILITY, - ): - self.interest_level: float = 0.0 - self.last_update_time: float = time.time() # 同时作为兴趣和概率的更新时间基准 - self.decay_rate_per_second: float = decay_rate - self.max_interest: float = max_interest - self.last_interaction_time: float = self.last_update_time # 新增：最后交互时间 - - # --- 新增：概率回复相关属性 --- - self.trigger_threshold: float = trigger_threshold - self.base_reply_probability: float = base_reply_probability - self.probability_increase_rate: float = increase_rate - self.probability_decay_factor: float = decay_factor - self.max_reply_probability: float = max_probability - self.current_reply_probability: float = 0.0 - self.is_above_threshold: bool = False # 标记兴趣值是否高于阈值 - # --- 结束：概率回复相关属性 --- - - # 记录激发兴趣对(消息id,激活值) - self.interest_dict = {} - - def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool): - # Store the MessageRecv object and the interest value as a tuple - self.interest_dict[message.message_info.message_id] = (message, interest_value, is_mentioned) - - def _calculate_decay(self, current_time: float): - """计算从上次更新到现在的衰减""" - time_delta = current_time - self.last_update_time - if time_delta > 0: - # 指数衰减: interest = interest * (decay_rate ^ time_delta) - # 添加处理极小兴趣值避免 math domain error - old_interest = self.interest_level - if self.interest_level < 1e-9: - self.interest_level = 0.0 - else: - # 检查 decay_rate_per_second 是否为非正数，避免 math domain error - if self.decay_rate_per_second <= 0: - logger.warning( - f"InterestChatting encountered non-positive decay rate: {self.decay_rate_per_second}. Setting interest to 0." - ) - self.interest_level = 0.0 - # 检查 interest_level 是否为负数，虽然理论上不应发生，但以防万一 - elif self.interest_level < 0: - logger.warning( - f"InterestChatting encountered negative interest level: {self.interest_level}. Setting interest to 0." - ) - self.interest_level = 0.0 - else: - try: - decay_factor = math.pow(self.decay_rate_per_second, time_delta) - self.interest_level *= decay_factor - except ValueError as e: - # 捕获潜在的 math domain error，例如对负数开非整数次方（虽然已加保护） - logger.error( - f"Math error during decay calculation: {e}. Rate: {self.decay_rate_per_second}, Delta: {time_delta}, Level: {self.interest_level}. Setting interest to 0." - ) - self.interest_level = 0.0 - - # 防止低于阈值 (如果需要) - # self.interest_level = max(self.interest_level, MIN_INTEREST_THRESHOLD) - - # 只有在兴趣值发生变化时才更新时间戳 - if old_interest != self.interest_level: - self.last_update_time = current_time - - def _update_reply_probability(self, current_time: float): - """根据当前兴趣是否超过阈值及时间差，更新回复概率""" - time_delta = current_time - self.last_update_time - if time_delta <= 0: - return # 时间未前进，无需更新 - - currently_above = self.interest_level >= self.trigger_threshold - - if currently_above: - if not self.is_above_threshold: - # 刚跨过阈值，重置为基础概率 - self.current_reply_probability = self.base_reply_probability - logger.debug( - f"兴趣跨过阈值 ({self.trigger_threshold}). 概率重置为基础值: {self.base_reply_probability:.4f}" - ) - else: - # 持续高于阈值，线性增加概率 - increase_amount = self.probability_increase_rate * time_delta - self.current_reply_probability += increase_amount - # logger.debug(f"兴趣高于阈值 ({self.trigger_threshold}) 持续 {time_delta:.2f}秒. 概率增加 {increase_amount:.4f} 到 {self.current_reply_probability:.4f}") - - # 限制概率不超过最大值 - self.current_reply_probability = min(self.current_reply_probability, self.max_reply_probability) - - else: - if 0 < self.probability_decay_factor < 1: - decay_multiplier = math.pow(self.probability_decay_factor, time_delta) - # old_prob = self.current_reply_probability - self.current_reply_probability *= decay_multiplier - # 避免因浮点数精度问题导致概率略微大于0，直接设为0 - if self.current_reply_probability < 1e-6: - self.current_reply_probability = 0.0 - # logger.debug(f"兴趣低于阈值 ({self.trigger_threshold}) 持续 {time_delta:.2f}秒. 概率从 {old_prob:.4f} 衰减到 {self.current_reply_probability:.4f} (因子: {self.probability_decay_factor})") - elif self.probability_decay_factor <= 0: - # 如果衰减因子无效或为0，直接清零 - if self.current_reply_probability > 0: - logger.warning(f"无效的衰减因子 ({self.probability_decay_factor}). 设置概率为0.") - self.current_reply_probability = 0.0 - # else: decay_factor >= 1, probability will not decay or increase, which might be intended in some cases. - - # 确保概率不低于0 - self.current_reply_probability = max(self.current_reply_probability, 0.0) - - # 更新状态标记 - self.is_above_threshold = currently_above - # 更新时间戳放在调用者处，确保 interest 和 probability 基于同一点更新 - - def increase_interest(self, current_time: float, value: float): - """根据传入的值增加兴趣值，并记录增加量""" - # 先更新概率和计算衰减（基于上次更新时间） - self._update_reply_probability(current_time) - self._calculate_decay(current_time) - # 应用增加 - self.interest_level += value - self.interest_level = min(self.interest_level, self.max_interest) # 不超过最大值 - self.last_update_time = current_time # 更新时间戳 - self.last_interaction_time = current_time # 更新最后交互时间 - - def decrease_interest(self, current_time: float, value: float): - """降低兴趣值并更新时间 (确保不低于0)""" - # 先更新概率（基于上次更新时间） - self._update_reply_probability(current_time) - # 注意：降低兴趣度是否需要先衰减？取决于具体逻辑，这里假设不衰减直接减 - self.interest_level -= value - self.interest_level = max(self.interest_level, 0.0) # 确保不低于0 - self.last_update_time = current_time # 降低也更新时间戳 - self.last_interaction_time = current_time # 更新最后交互时间 - - def get_interest(self) -> float: - """获取当前兴趣值 (计算衰减后)""" - # 注意：这个方法现在会触发概率和兴趣的更新 - current_time = time.time() - self._update_reply_probability(current_time) - self._calculate_decay(current_time) - self.last_update_time = current_time # 更新时间戳 - return self.interest_level - - def get_state(self) -> dict: - """获取当前状态字典""" - # 调用 get_interest 来确保状态已更新 - interest = self.get_interest() - return { - "interest_level": round(interest, 2), - "last_update_time": self.last_update_time, - "current_reply_probability": round(self.current_reply_probability, 4), # 添加概率到状态 - "is_above_threshold": self.is_above_threshold, # 添加阈值状态 - "last_interaction_time": self.last_interaction_time, # 新增：添加最后交互时间到状态 - # 可以选择性地暴露 last_increase_amount 给状态，方便调试 - # "last_increase_amount": round(self.last_increase_amount, 2) - } - - def should_evaluate_reply(self) -> bool: - """ - 判断是否应该触发一次回复评估。 - 首先更新概率状态，然后根据当前概率进行随机判断。 - """ - current_time = time.time() - # 确保概率是基于最新兴趣值计算的 - self._update_reply_probability(current_time) - # 更新兴趣衰减（如果需要，取决于逻辑，这里保持和 get_interest 一致） - # self._calculate_decay(current_time) - # self.last_update_time = current_time # 更新时间戳 - - if self.current_reply_probability > 0: - # 只有在阈值之上且概率大于0时才有可能触发 - trigger = random.random() < self.current_reply_probability - # if trigger: - # logger.info(f"回复概率评估触发! 概率: {self.current_reply_probability:.4f}, 阈值: {self.trigger_threshold}, 兴趣: {self.interest_level:.2f}") - # # 可选：触发后是否重置/降低概率？根据需要决定 - # # self.current_reply_probability = self.base_reply_probability # 例如，触发后降回基础概率 - # # self.current_reply_probability *= 0.5 # 例如，触发后概率减半 - # else: - # logger.debug(f"回复概率评估未触发。概率: {self.current_reply_probability:.4f}") - return trigger - else: - # logger.debug(f"Reply evaluation check: Below threshold or zero probability. Probability: {self.current_reply_probability:.4f}") - return False - - -class InterestManager: - _instance = None - _lock = threading.Lock() - _initialized = False - - def __new__(cls, *args, **kwargs): - if cls._instance is None: - with cls._lock: - # Double-check locking - if cls._instance is None: - cls._instance = super().__new__(cls) - return cls._instance - - def __init__(self): - if not self._initialized: - with self._lock: - # 确保初始化也只执行一次 - if not self._initialized: - logger.info("Initializing InterestManager singleton...") - # key: stream_id (str), value: InterestChatting instance - self.interest_dict: dict[str, InterestChatting] = {} - # 保留旧的快照文件路径变量，尽管此任务不再写入 - # self._snapshot_log_file_path = os.path.join(LOG_DIRECTORY, LOG_FILENAME) - # 定义新的历史日志文件路径 - self._history_log_file_path = os.path.join(LOG_DIRECTORY, HISTORY_LOG_FILENAME) - self._ensure_log_directory() - self._cleanup_task = None - self._logging_task = None # 添加日志任务变量 - self._initialized = True - logger.info("InterestManager initialized.") # 修改日志消息 - self._decay_task = None # 新增：衰减任务变量 - - def _ensure_log_directory(self): - """确保日志目录存在""" - try: - os.makedirs(LOG_DIRECTORY, exist_ok=True) - logger.info(f"Log directory '{LOG_DIRECTORY}' ensured.") - except OSError as e: - logger.error(f"Error creating log directory '{LOG_DIRECTORY}': {e}") - - async def _periodic_cleanup_task(self, interval_seconds: int, max_age_seconds: int): - """后台清理任务的异步函数""" - while True: - await asyncio.sleep(interval_seconds) - logger.info(f"运行定期清理 (间隔: {interval_seconds}秒)...") - self.cleanup_inactive_chats(max_age_seconds=max_age_seconds) - - async def _periodic_log_task(self, interval_seconds: int): - """后台日志记录任务的异步函数 (记录历史数据，包含 group_name)""" - while True: - await asyncio.sleep(interval_seconds) - # logger.debug(f"运行定期历史记录 (间隔: {interval_seconds}秒)...") - try: - current_timestamp = time.time() - all_states = self.get_all_interest_states() # 获取当前所有状态 - - # 以追加模式打开历史日志文件 - with open(self._history_log_file_path, "a", encoding="utf-8") as f: - count = 0 - for stream_id, state in all_states.items(): - # *** Get group name from ChatManager *** - group_name = stream_id # Default to stream_id - try: - # Use the imported chat_manager instance - chat_stream = chat_manager.get_stream(stream_id) - if chat_stream and chat_stream.group_info: - group_name = chat_stream.group_info.group_name - elif chat_stream and not chat_stream.group_info: - # Handle private chats - maybe use user nickname? - group_name = ( - f"私聊_{chat_stream.user_info.user_nickname}" - if chat_stream.user_info - else stream_id - ) - except Exception as e: - logger.warning(f"Could not get group name for stream_id {stream_id}: {e}") - # Fallback to stream_id is already handled by default value - - log_entry = { - "timestamp": round(current_timestamp, 2), - "stream_id": stream_id, - "interest_level": state.get("interest_level", 0.0), # 确保有默认值 - "group_name": group_name, # *** Add group_name *** - # --- 新增：记录概率相关信息 --- - "reply_probability": state.get("current_reply_probability", 0.0), - "is_above_threshold": state.get("is_above_threshold", False), - # --- 结束新增 --- - } - # 将每个条目作为单独的 JSON 行写入 - f.write(json.dumps(log_entry, ensure_ascii=False) + "\n") - count += 1 - # logger.debug(f"Successfully appended {count} interest history entries to {self._history_log_file_path}") - - # 注意：不再写入快照文件 interest_log.json - # 如果需要快照文件，可以在这里单独写入 self._snapshot_log_file_path - # 例如： - # with open(self._snapshot_log_file_path, 'w', encoding='utf-8') as snap_f: - # json.dump(all_states, snap_f, indent=4, ensure_ascii=False) - # logger.debug(f"Successfully wrote snapshot to {self._snapshot_log_file_path}") - - except IOError as e: - logger.error(f"Error writing interest history log to {self._history_log_file_path}: {e}") - except Exception as e: - logger.error(f"Unexpected error during periodic history logging: {e}") - - async def _periodic_decay_task(self): - """后台衰减任务的异步函数，每秒更新一次所有实例的衰减""" - while True: - await asyncio.sleep(1) # 每秒运行一次 - current_time = time.time() - # logger.debug("Running periodic decay calculation...") # 调试日志，可能过于频繁 - - # 创建字典项的快照进行迭代，避免在迭代时修改字典的问题 - items_snapshot = list(self.interest_dict.items()) - count = 0 - for stream_id, chatting in items_snapshot: - try: - # 调用 InterestChatting 实例的衰减方法 - chatting._calculate_decay(current_time) - count += 1 - except Exception as e: - logger.error(f"Error calculating decay for stream_id {stream_id}: {e}") - # if count > 0: # 仅在实际处理了项目时记录日志，避免空闲时刷屏 - # logger.debug(f"Applied decay to {count} streams.") - - async def start_background_tasks(self): - """启动清理，启动衰减，启动记录，启动启动启动启动启动""" - if self._cleanup_task is None or self._cleanup_task.done(): - self._cleanup_task = asyncio.create_task( - self._periodic_cleanup_task( - interval_seconds=CLEANUP_INTERVAL_SECONDS, max_age_seconds=INACTIVE_THRESHOLD_SECONDS - ) - ) - logger.info( - f"已创建定期清理任务。间隔时间: {CLEANUP_INTERVAL_SECONDS}秒, 不活跃阈值: {INACTIVE_THRESHOLD_SECONDS}秒" - ) - else: - logger.warning("跳过创建清理任务:任务已在运行或存在。") - - if self._logging_task is None or self._logging_task.done(): - self._logging_task = asyncio.create_task(self._periodic_log_task(interval_seconds=LOG_INTERVAL_SECONDS)) - logger.info(f"已创建定期日志任务。间隔时间: {LOG_INTERVAL_SECONDS}秒") - else: - logger.warning("跳过创建日志任务:任务已在运行或存在。") - - # 启动新的衰减任务 - if self._decay_task is None or self._decay_task.done(): - self._decay_task = asyncio.create_task(self._periodic_decay_task()) - logger.info("已创建定期衰减任务。间隔时间: 1秒") - else: - logger.warning("跳过创建衰减任务:任务已在运行或存在。") - - def get_all_interest_states(self) -> dict[str, dict]: - """获取所有聊天流的当前兴趣状态""" - # 不再需要 current_time, 因为 get_state 现在不接收它 - states = {} - # 创建副本以避免在迭代时修改字典 - items_snapshot = list(self.interest_dict.items()) - for stream_id, chatting in items_snapshot: - try: - # 直接调用 get_state，它会使用内部的 get_interest 获取已更新的值 - states[stream_id] = chatting.get_state() - except Exception as e: - logger.warning(f"Error getting state for stream_id {stream_id}: {e}") - return states - - def get_interest_chatting(self, stream_id: str) -> Optional[InterestChatting]: - """获取指定流的 InterestChatting 实例，如果不存在则返回 None""" - return self.interest_dict.get(stream_id) - - def _get_or_create_interest_chatting(self, stream_id: str) -> InterestChatting: - """获取或创建指定流的 InterestChatting 实例 (线程安全)""" - if stream_id not in self.interest_dict: - logger.debug(f"创建兴趣流: {stream_id}") - # --- 修改：创建时传入概率相关参数 (如果需要定制化，否则使用默认值) --- - self.interest_dict[stream_id] = InterestChatting( - # decay_rate=..., max_interest=..., # 可以从配置读取 - trigger_threshold=REPLY_TRIGGER_THRESHOLD, # 使用全局常量 - base_reply_probability=BASE_REPLY_PROBABILITY, - increase_rate=PROBABILITY_INCREASE_RATE_PER_SECOND, - decay_factor=PROBABILITY_DECAY_FACTOR_PER_SECOND, - max_probability=MAX_REPLY_PROBABILITY, - ) - # --- 结束修改 --- - # 首次创建时兴趣为 0，由第一次消息的 activate rate 决定初始值 - return self.interest_dict[stream_id] - - def get_interest(self, stream_id: str) -> float: - """获取指定聊天流当前的兴趣度 (值由后台任务更新)""" - # current_time = time.time() # 不再需要获取当前时间 - interest_chatting = self._get_or_create_interest_chatting(stream_id) - # 直接调用修改后的 get_interest，不传入时间 - return interest_chatting.get_interest() - - def increase_interest(self, stream_id: str, value: float): - """当收到消息时，增加指定聊天流的兴趣度""" - current_time = time.time() - interest_chatting = self._get_or_create_interest_chatting(stream_id) - # 调用修改后的 increase_interest，不再传入 message - interest_chatting.increase_interest(current_time, value) - stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 - logger.debug( - f"增加了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}" - ) # 更新日志 - - def decrease_interest(self, stream_id: str, value: float): - """降低指定聊天流的兴趣度""" - current_time = time.time() - # 尝试获取，如果不存在则不做任何事 - interest_chatting = self.get_interest_chatting(stream_id) - if interest_chatting: - interest_chatting.decrease_interest(current_time, value) - stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 - logger.debug( - f"降低了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}" - ) - else: - stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 - logger.warning(f"尝试降低不存在的聊天流 {stream_name} 的兴趣度") - - def add_interest_dict(self, message: MessageRecv, interest_value: float, is_mentioned: bool): - interest_chatting = self._get_or_create_interest_chatting(message.chat_stream.stream_id) - interest_chatting.add_interest_dict(message, interest_value, is_mentioned) - - def cleanup_inactive_chats(self, max_age_seconds=INACTIVE_THRESHOLD_SECONDS): - """ - 清理长时间不活跃的聊天流记录 - max_age_seconds: 超过此时间未更新的将被清理 - """ - current_time = time.time() - keys_to_remove = [] - initial_count = len(self.interest_dict) - # with self._lock: # 如果需要锁整个迭代过程 - # 创建副本以避免在迭代时修改字典 - items_snapshot = list(self.interest_dict.items()) - - for stream_id, chatting in items_snapshot: - # 先计算当前兴趣，确保是最新的 - # 加锁保护 chatting 对象状态的读取和可能的修改 - # with self._lock: # 如果 InterestChatting 内部操作不是原子的 - last_interaction = chatting.last_interaction_time # 使用最后交互时间 - should_remove = False - reason = "" - # 只有设置了 max_age_seconds 才检查时间 - if ( - max_age_seconds is not None and (current_time - last_interaction) > max_age_seconds - ): # 使用 last_interaction - should_remove = True - reason = f"inactive time ({current_time - last_interaction:.0f}s) > max age ({max_age_seconds}s)" # 更新日志信息 - - if should_remove: - keys_to_remove.append(stream_id) - stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称 - logger.debug(f"Marking stream {stream_name} for removal. Reason: {reason}") - - if keys_to_remove: - logger.info(f"清理识别到 {len(keys_to_remove)} 个不活跃/低兴趣的流。") - # with self._lock: # 确保删除操作的原子性 - for key in keys_to_remove: - # 再次检查 key 是否存在，以防万一在迭代和删除之间状态改变 - if key in self.interest_dict: - del self.interest_dict[key] - stream_name = chat_manager.get_stream_name(key) or key # 获取流名称 - logger.debug(f"移除了流: {stream_name}") - final_count = initial_count - len(keys_to_remove) - logger.info(f"清理完成。移除了 {len(keys_to_remove)} 个流。当前数量: {final_count}") - else: - logger.info(f"清理完成。没有流符合移除条件。当前数量: {initial_count}") diff --git a/src/plugins/chat_module/heartFC_chat/pf_chatting.py b/src/plugins/chat_module/heartFC_chat/pf_chatting.py index 92e3da54..12a0e8ec 100644 --- a/src/plugins/chat_module/heartFC_chat/pf_chatting.py +++ b/src/plugins/chat_module/heartFC_chat/pf_chatting.py @@ -753,7 +753,7 @@ class PFChatting: # --- Generate Response with LLM --- # # Access gpt instance via controller gpt_instance = self.heartfc_controller.gpt - logger.debug(f"{log_prefix}[Replier-{thinking_id}] Calling LLM to generate response...") + # logger.debug(f"{log_prefix}[Replier-{thinking_id}] Calling LLM to generate response...") # Ensure generate_response has access to current_mind if it's crucial context response_set = await gpt_instance.generate_response( diff --git a/src/plugins/chat_module/heartFC_chat/reasoning_chat.py b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py index 5a9732d9..addcd53d 100644 --- a/src/plugins/chat_module/heartFC_chat/reasoning_chat.py +++ b/src/plugins/chat_module/heartFC_chat/reasoning_chat.py @@ -20,8 +20,8 @@ from src.plugins.chat.chat_stream import ChatStream from src.plugins.person_info.relationship_manager import relationship_manager from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager from src.plugins.utils.timer_calculater import Timer -from .interest import InterestManager -from .heartFC_controler import HeartFCController # 导入 HeartFCController +from src.heart_flow.heartflow import heartflow +from .heartFC_controler import HeartFCController # 定义日志配置 chat_config = LogConfig( @@ -56,11 +56,9 @@ class ReasoningChat: self.storage = MessageStorage() self.gpt = ResponseGenerator() self.mood_manager = MoodManager.get_instance() - self.mood_manager.start_mood_update() # 用于存储每个 chat stream 的兴趣监控任务 self._interest_monitoring_tasks: Dict[str, asyncio.Task] = {} self._initialized = True - self.interest_manager = InterestManager() logger.info("ReasoningChat 单例初始化完成。") # 添加日志 @classmethod @@ -182,55 +180,69 @@ class ReasoningChat: # 此函数设计为后台任务，轮询指定 chat 的兴趣消息。 # 它通常由外部代码在 chat 流活跃时启动。 controller = HeartFCController.get_instance() # 获取控制器实例 + stream_id = chat.stream_id # 获取 stream_id + if not controller: - logger.error(f"无法获取 HeartFCController 实例，无法检查 PFChatting 状态。stream: {chat.stream_id}") + logger.error(f"无法获取 HeartFCController 实例，无法检查 PFChatting 状态。stream: {stream_id}") # 在没有控制器的情况下可能需要决定是继续处理还是完全停止？这里暂时假设继续 pass # 或者 return? + logger.info(f"[{stream_id}] 兴趣消息监控任务启动。") # 增加启动日志 while True: await asyncio.sleep(1) # 每秒检查一次 - interest_chatting = self.interest_manager.get_interest_chatting(chat.stream_id) - if not interest_chatting: - continue + # --- 修改：通过 heartflow 获取 subheartflow 和 interest_dict --- # + subheartflow = heartflow.get_subheartflow(stream_id) - interest_dict = interest_chatting.interest_dict if interest_chatting.interest_dict else {} + # 检查 subheartflow 是否存在以及是否被标记停止 + if not subheartflow or subheartflow.should_stop: + logger.info(f"[{stream_id}] SubHeartflow 不存在或已停止，兴趣消息监控任务退出。") + break # 退出循环，任务结束 + + # 从 subheartflow 获取 interest_dict + interest_dict = subheartflow.get_interest_dict() + # --- 结束修改 --- # + + # 创建 items 快照进行迭代，避免在迭代时修改字典 items_to_process = list(interest_dict.items()) if not items_to_process: - continue + continue # 没有需要处理的消息，继续等待 + + # logger.debug(f"[{stream_id}] 发现 {len(items_to_process)} 条待处理兴趣消息。") # 调试日志 for msg_id, (message, interest_value, is_mentioned) in items_to_process: # --- 检查 PFChatting 是否活跃 --- # pf_active = False if controller: - pf_active = controller.is_pf_chatting_active(chat.stream_id) + pf_active = controller.is_pf_chatting_active(stream_id) if pf_active: # 如果 PFChatting 活跃，则跳过处理，直接移除消息 removed_item = interest_dict.pop(msg_id, None) if removed_item: - logger.debug(f"PFChatting 活跃，已跳过并移除兴趣消息 {msg_id} for stream: {chat.stream_id}") + logger.debug(f"[{stream_id}] PFChatting 活跃，已跳过并移除兴趣消息 {msg_id}") continue # 处理下一条消息 # --- 结束检查 --- # # 只有当 PFChatting 不活跃时才执行以下处理逻辑 try: - # logger.debug(f"正在处理消息 {msg_id} for stream: {chat.stream_id}") # 可选调试信息 + # logger.debug(f"[{stream_id}] 正在处理兴趣消息 {msg_id} (兴趣值: {interest_value:.2f})" ) await self.normal_reasoning_chat( message=message, - chat=chat, + chat=chat, # chat 对象仍然有效 is_mentioned=is_mentioned, - interested_rate=interest_value, + interested_rate=interest_value, # 使用从字典获取的原始兴趣值 ) - # logger.debug(f"处理完成消息 {msg_id}") # 可选调试信息 + # logger.debug(f"[{stream_id}] 处理完成消息 {msg_id}") except Exception as e: - logger.error(f"处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}") + logger.error(f"[{stream_id}] 处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}") finally: # 无论处理成功与否（且PFChatting不活跃），都尝试从原始字典中移除该消息 + # 使用 pop(key, None) 避免 Key Error removed_item = interest_dict.pop(msg_id, None) if removed_item: - logger.debug(f"已从兴趣字典中移除消息 {msg_id}") + logger.debug(f"[{stream_id}] 已从兴趣字典中移除消息 {msg_id}") async def normal_reasoning_chat( self, message: MessageRecv, chat: ChatStream, is_mentioned: bool, interested_rate: float @@ -281,7 +293,10 @@ class ReasoningChat: # 生成回复 try: with Timer("生成回复", timing_results): - response_set = await self.gpt.generate_response(message, thinking_id) + response_set = await self.gpt.generate_response( + message=message, + thinking_id=thinking_id, + ) info_catcher.catch_after_generate_response(timing_results["生成回复"]) except Exception as e: @@ -289,23 +304,34 @@ class ReasoningChat: response_set = None if not response_set: - logger.info("为什么生成回复失败？") - return + logger.info(f"[{chat.stream_id}] 模型未生成回复内容") + # 如果模型未生成回复，移除思考消息 + container = message_manager.get_container(chat.stream_id) + # thinking_message = None + for msg in container.messages[:]: # Iterate over a copy + if isinstance(msg, MessageThinking) and msg.message_info.message_id == thinking_id: + # thinking_message = msg + container.messages.remove(msg) + logger.debug(f"[{chat.stream_id}] 已移除未产生回复的思考消息 {thinking_id}") + break + return # 不发送回复 - # 发送消息 - with Timer("发送消息", timing_results): + logger.info(f"[{chat.stream_id}] 回复内容: {response_set}") + + # 发送回复 + with Timer("消息发送", timing_results): first_bot_msg = await self._send_response_messages(message, chat, response_set, thinking_id) - info_catcher.catch_after_response(timing_results["发送消息"], response_set, first_bot_msg) + info_catcher.catch_after_response(timing_results["消息发送"], response_set, first_bot_msg) info_catcher.done_catch() # 处理表情包 with Timer("处理表情包", timing_results): - await self._handle_emoji(message, chat, response_set) + await self._handle_emoji(message, chat, response_set[0]) # 更新关系情绪 - with Timer("更新关系情绪", timing_results): + with Timer("关系更新", timing_results): await self._update_relationship(message, response_set) # 回复后处理 @@ -349,64 +375,51 @@ class ReasoningChat: return False async def start_monitoring_interest(self, chat: ChatStream): - """为指定的 ChatStream 启动后台兴趣消息监控任务。""" + """为指定的 ChatStream 启动兴趣消息监控任务（如果尚未运行）。""" stream_id = chat.stream_id - # 检查任务是否已在运行 - if stream_id in self._interest_monitoring_tasks and not self._interest_monitoring_tasks[stream_id].done(): - task = self._interest_monitoring_tasks[stream_id] - if not task.cancelled(): # 确保任务未被取消 - logger.info(f"兴趣监控任务已在运行 stream: {stream_id}") - return - else: - logger.info(f"发现已取消的任务，重新创建 stream: {stream_id}") - # 如果任务被取消了，允许重新创建 - - logger.info(f"启动兴趣监控任务 stream: {stream_id}...") - # 创建新的后台任务来运行 _find_interested_message - task = asyncio.create_task(self._find_interested_message(chat)) - self._interest_monitoring_tasks[stream_id] = task - - # 添加回调，当任务完成（或被取消）时，自动从字典中移除 - task.add_done_callback(lambda t: self._handle_task_completion(stream_id, t)) + if stream_id not in self._interest_monitoring_tasks or self._interest_monitoring_tasks[stream_id].done(): + logger.info(f"为聊天流 {stream_id} 启动兴趣消息监控任务...") + # 创建新任务 + task = asyncio.create_task(self._find_interested_message(chat)) + # 添加完成回调 + task.add_done_callback(lambda t: self._handle_task_completion(stream_id, t)) + self._interest_monitoring_tasks[stream_id] = task + # else: + # logger.debug(f"聊天流 {stream_id} 的兴趣消息监控任务已在运行。") def _handle_task_completion(self, stream_id: str, task: asyncio.Task): - """处理监控任务完成的回调。""" + """兴趣监控任务完成时的回调函数。""" try: # 检查任务是否因异常而结束 exception = task.exception() if exception: - logger.error(f"兴趣监控任务 stream {stream_id} 异常结束: {exception}", exc_info=exception) - elif task.cancelled(): - logger.info(f"兴趣监控任务 stream {stream_id} 已被取消。") + logger.error(f"聊天流 {stream_id} 的兴趣监控任务因异常结束: {exception}") + logger.error(traceback.format_exc()) # 记录完整的 traceback else: - logger.info(f"兴趣监控任务 stream {stream_id} 正常结束。") # 理论上 while True 不会正常结束 + logger.info(f"聊天流 {stream_id} 的兴趣监控任务正常结束。") except asyncio.CancelledError: - logger.info(f"兴趣监控任务 stream {stream_id} 在完成处理期间被取消。") + logger.info(f"聊天流 {stream_id} 的兴趣监控任务被取消。") + except Exception as e: + logger.error(f"处理聊天流 {stream_id} 任务完成回调时出错: {e}") finally: - # 无论如何都从字典中移除 - removed_task = self._interest_monitoring_tasks.pop(stream_id, None) - if removed_task: - logger.debug(f"已从监控任务字典移除 stream: {stream_id}") + # 从字典中移除已完成或取消的任务 + if stream_id in self._interest_monitoring_tasks: + del self._interest_monitoring_tasks[stream_id] + logger.debug(f"已从监控任务字典中移除 {stream_id}") async def stop_monitoring_interest(self, stream_id: str): - """停止指定 stream_id 的兴趣消息监控任务。""" + """停止指定聊天流的兴趣监控任务。""" if stream_id in self._interest_monitoring_tasks: task = self._interest_monitoring_tasks[stream_id] - if not task.done(): - logger.info(f"正在停止兴趣监控任务 stream: {stream_id}...") - task.cancel() # 请求取消任务 + if task and not task.done(): + task.cancel() # 尝试取消任务 + logger.info(f"尝试取消聊天流 {stream_id} 的兴趣监控任务。") try: - # 等待任务实际被取消（可选，提供更明确的停止） - # 设置超时以防万一 - await asyncio.wait_for(task, timeout=5.0) + await task # 等待任务响应取消 except asyncio.CancelledError: - logger.info(f"兴趣监控任务 stream {stream_id} 已确认取消。") - except asyncio.TimeoutError: - logger.warning(f"停止兴趣监控任务 stream {stream_id} 超时。任务可能仍在运行。") + logger.info(f"聊天流 {stream_id} 的兴趣监控任务已成功取消。") except Exception as e: - # 捕获 task.exception() 可能在取消期间重新引发的错误 - logger.error(f"停止兴趣监控任务 stream {stream_id} 时发生错误: {e}") - # 任务最终会由 done_callback 移除，或在这里再次确认移除 - self._interest_monitoring_tasks.pop(stream_id, None) - else: - logger.warning(f"尝试停止不存在或已停止的监控任务 stream: {stream_id}") + logger.error(f"等待聊天流 {stream_id} 监控任务取消时出现异常: {e}") + # 在回调函数 _handle_task_completion 中移除任务 + # else: + # logger.debug(f"聊天流 {stream_id} 没有正在运行的兴趣监控任务可停止。") diff --git a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py index 50613a98..5455aed6 100644 --- a/src/plugins/chat_module/reasoning_chat/reasoning_chat.py +++ b/src/plugins/chat_module/reasoning_chat/reasoning_chat.py @@ -36,7 +36,6 @@ class ReasoningChat: self.storage = MessageStorage() self.gpt = ResponseGenerator() self.mood_manager = MoodManager.get_instance() - self.mood_manager.start_mood_update() @staticmethod async def _create_thinking_message(message, chat, userinfo, messageinfo): diff --git a/src/plugins/person_info/person_info.py b/src/plugins/person_info/person_info.py index b4404988..d903213f 100644 --- a/src/plugins/person_info/person_info.py +++ b/src/plugins/person_info/person_info.py @@ -198,9 +198,9 @@ class PersonInfoManager: "nickname": "昵称", "reason": "理由" }""" - logger.debug(f"取名提示词：{qv_name_prompt}") + # logger.debug(f"取名提示词：{qv_name_prompt}") response = await self.qv_name_llm.generate_response(qv_name_prompt) - logger.debug(f"取名回复：{response}") + logger.debug(f"取名提示词：{qv_name_prompt}\n取名回复：{response}") result = self._extract_json_from_text(response[0]) if not result["nickname"]: @@ -217,7 +217,7 @@ class PersonInfoManager: await self.update_one_field(person_id, "name_reason", result["reason"]) self.person_name_list[person_id] = result["nickname"] - logger.debug(f"用户 {person_id} 的名称已更新为 {result['nickname']}，原因：{result['reason']}") + # logger.debug(f"用户 {person_id} 的名称已更新为 {result['nickname']}，原因：{result['reason']}") return result else: existing_names += f"{result['nickname']}、" diff --git a/src/plugins/person_info/relationship_manager.py b/src/plugins/person_info/relationship_manager.py index 556e59f4..a688242b 100644 --- a/src/plugins/person_info/relationship_manager.py +++ b/src/plugins/person_info/relationship_manager.py @@ -89,8 +89,8 @@ class RelationshipManager: person_id = person_info_manager.get_person_id(platform, user_id) is_qved = await person_info_manager.has_one_field(person_id, "person_name") old_name = await person_info_manager.get_value(person_id, "person_name") - print(f"old_name: {old_name}") - print(f"is_qved: {is_qved}") + # print(f"old_name: {old_name}") + # print(f"is_qved: {is_qved}") if is_qved and old_name is not None: return True else: From 6a21f3408e7f3981275cba4dbf57daa3b3656c3a Mon Sep 17 00:00:00 2001 From: Bakadax Date: Tue, 22 Apr 2025 09:29:47 +0800 Subject: [PATCH 23/26] modified: src/plugins/chat/utils.py --- src/plugins/chat/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index 739fc6c7..ed316635 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -76,12 +76,12 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]: else: if not is_mentioned: # 判断是否被回复 - if re.match(f"回复[\s\S]*?\({global_config.BOT_QQ}\)的消息，说：", message.processed_plain_text): + if re.match(f"\[回复 [\s\S]*?\({str(global_config.BOT_QQ)}\)：[\s\S]*?\]，说：", message.processed_plain_text): is_mentioned = True # 判断内容中是否被提及 message_content = re.sub(r"@[\s\S]*?（(\d+)）", "", message.processed_plain_text) - message_content = re.sub(r"回复[\s\S]*?\((\d+)\)的消息，说： ", "", message_content) + message_content = re.sub(r"\[回复 [\s\S]*?\((\d+)|未知id\)：[\s\S]*?\]，说：", "", message_content) for keyword in keywords: if keyword in message_content: is_mentioned = True From 273647f958ce19271789d72567f1b4e8a0f66c71 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 22 Apr 2025 01:30:21 +0000 Subject: [PATCH 24/26] =?UTF-8?q?=F0=9F=A4=96=20=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=8C=96=E4=BB=A3=E7=A0=81=20[skip=20ci]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/chat/utils.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index ed316635..48ddc12c 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -76,7 +76,9 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]: else: if not is_mentioned: # 判断是否被回复 - if re.match(f"\[回复 [\s\S]*?\({str(global_config.BOT_QQ)}\)：[\s\S]*?\]，说：", message.processed_plain_text): + if re.match( + f"\[回复 [\s\S]*?\({str(global_config.BOT_QQ)}\)：[\s\S]*?\]，说：", message.processed_plain_text + ): is_mentioned = True # 判断内容中是否被提及 From 062d6d46b785e1cc27362ca3acfb67f17d1c0c19 Mon Sep 17 00:00:00 2001 From: Bakadax Date: Tue, 22 Apr 2025 09:34:10 +0800 Subject: [PATCH 25/26] modified: src/plugins/chat/utils.py --- src/plugins/chat/utils.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index ed316635..36656dc9 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -78,16 +78,16 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]: # 判断是否被回复 if re.match(f"\[回复 [\s\S]*?\({str(global_config.BOT_QQ)}\)：[\s\S]*?\]，说：", message.processed_plain_text): is_mentioned = True - - # 判断内容中是否被提及 - message_content = re.sub(r"@[\s\S]*?（(\d+)）", "", message.processed_plain_text) - message_content = re.sub(r"\[回复 [\s\S]*?\((\d+)|未知id\)：[\s\S]*?\]，说：", "", message_content) - for keyword in keywords: - if keyword in message_content: - is_mentioned = True - for nickname in nicknames: - if nickname in message_content: - is_mentioned = True + else: + # 判断内容中是否被提及 + message_content = re.sub(r"@[\s\S]*?（(\d+)）", "", message.processed_plain_text) + message_content = re.sub(r"\[回复 [\s\S]*?\((\d+)|未知id\)：[\s\S]*?\]，说：", "", message_content) + for keyword in keywords: + if keyword in message_content: + is_mentioned = True + for nickname in nicknames: + if nickname in message_content: + is_mentioned = True if is_mentioned and global_config.mentioned_bot_inevitable_reply: reply_probability = 1.0 logger.info("被提及，回复概率设置为100%") From e3271e354b9a820ff3744bf4056f0952f5ba01ab Mon Sep 17 00:00:00 2001 From: Bakadax Date: Tue, 22 Apr 2025 11:03:33 +0800 Subject: [PATCH 26/26] =?UTF-8?q?=E5=91=9C=E5=91=9C~=E8=AE=A8=E5=8E=8C?= =?UTF-8?q?=E6=AD=A3=E5=88=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/plugins/chat/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/chat/utils.py b/src/plugins/chat/utils.py index 55d6f62b..271386ff 100644 --- a/src/plugins/chat/utils.py +++ b/src/plugins/chat/utils.py @@ -83,7 +83,7 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]: else: # 判断内容中是否被提及 message_content = re.sub(r"@[\s\S]*?（(\d+)）", "", message.processed_plain_text) - message_content = re.sub(r"\[回复 [\s\S]*?\((\d+)|未知id\)：[\s\S]*?\]，说：", "", message_content) + message_content = re.sub(r"\[回复 [\s\S]*?\(((\d+)|未知id)\)：[\s\S]*?\]，说：", "", message_content) for keyword in keywords: if keyword in message_content: is_mentioned = True