sycommon-python-lib 0.2.0b17__tar.gz → 0.2.0b19__tar.gz

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b17
+Version: 0.2.0b19
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b17"
+version = "0.2.0b19"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/src/sycommon/database/async_base_db_service.py

@@ -8,13 +8,7 @@ from sycommon.logging.kafka_log import SYLogger
 class AsyncBaseDBService(metaclass=SingletonMeta):
     """数据库操作基础服务类，封装异步会话管理功能"""
 
-    _initialized: bool = False
-
     def __init__(self):
-        if AsyncBaseDBService._initialized:
-            return
-        AsyncBaseDBService._initialized = True
-
         # 获取异步引擎 (假设 DatabaseService.engine() 返回的是 AsyncEngine)
         self.engine = AsyncDatabaseService.engine()
 

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/src/sycommon/database/base_db_service.py

@@ -8,13 +8,7 @@ from sycommon.logging.kafka_log import SYLogger
 class BaseDBService(metaclass=SingletonMeta):
     """数据库操作基础服务类，封装会话管理功能"""
 
-    _initialized: bool = False
-
     def __init__(self):
-        if BaseDBService._initialized:
-            return
-        BaseDBService._initialized = True
-
         self.engine = DatabaseService.engine()
         self.Session = sessionmaker(bind=self.engine)
 

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/src/sycommon/llm/get_llm.py

@@ -2,7 +2,7 @@ from sycommon.llm.llm_logger import LLMLogger
 from langchain.chat_models import init_chat_model
 from sycommon.config.LLMConfig import LLMConfig
 from sycommon.llm.sy_langfuse import LangfuseInitializer
-from sycommon.llm.usage_token import LLMWithAutoTokenUsage
+from sycommon.llm.usage_token import LLMWithAutoTokenUsage, LLMWithTokenTracking
 from typing import Any, Union
 from langchain_core.language_models import BaseChatModel
 
@@ -16,19 +16,19 @@ def get_llm(
     max_retries: int = 3,
     wrap_structured: bool = True,
     **kwargs: Any
-) -> Union[LLMWithAutoTokenUsage, BaseChatModel]:
+) -> Union[LLMWithAutoTokenUsage, LLMWithTokenTracking, BaseChatModel]:
     """
     获取LLM实例
 
     Args:
-        model: 模型名称，默认为 Qwen2.5-72B
+        model: 模型名称，默认为 Qwen3.5-122B-A10B
         streaming: 是否启用流式输出
         temperature: 温度参数
         timeout: 请求超时时间（秒），默认180秒
         max_retries: 最大重试次数，默认3次
         wrap_structured: 是否包装为结构化输出实例，默认True
             - True: 返回 LLMWithAutoTokenUsage，支持 with_structured_output()
-            - False: 返回原始 BaseChatModel，保留日志和 Langfuse 跟踪
+            - False: 返回 LLMWithTokenTracking，保留日志、Langfuse 跟踪和 Token 统计
         **kwargs: 其他透传参数，支持 langchain init_chat_model 所有参数
             - presence_penalty: 存在惩罚
             - extra_body: 额外请求体参数，如 {"top_k": 20, "chat_template_kwargs": {"enable_thinking": False}}
@@ -38,17 +38,20 @@ def get_llm(
             - summary_prompt: 结构化输出时的摘要提示词（仅 wrap_structured=True 时有效）
 
     Returns:
-        LLMWithAutoTokenUsage | BaseChatModel: 根据 wrap_structured 参数返回对应类型
+        LLMWithAutoTokenUsage | LLMWithTokenTracking | BaseChatModel: 根据 wrap_structured 参数返回对应类型
 
     Example:
         ```python
-        # 结构化输出（默认）
-        llm = get_llm("Qwen2.5-72B")
+        # 结构化输出（默认使用原生模式）
+        llm = get_llm("Qwen3.5-122B-A10B")
         chain = llm.with_structured_output(MyModel)
+        result = await chain.ainvoke([HumanMessage(content="你好")])
+        print(result._token_usage_)  # Token 统计
 
-        # 普通 LLM 调用，保留日志和 Langfuse
-        llm = get_llm("Qwen2.5-72B", wrap_structured=False)
+        # 普通 LLM 调用，保留日志、Langfuse 和 Token 统计
+        llm = get_llm("Qwen3.5-122B-A10B", wrap_structured=False)
         response = await llm.ainvoke([HumanMessage(content="你好")])
+        print(response._token_usage_)  # Token 统计
 
         # 透传额外参数
         llm = get_llm(
@@ -63,7 +66,6 @@ def get_llm(
         ```
     """
     if not model or model == "Qwen2.5-72B":
-        # model = "Qwen2.5-72B"
         model = "Qwen3.5-122B-A10B"
         kwargs["presence_penalty"] = 0
         kwargs["extra_body"] = {
@@ -99,11 +101,14 @@ def get_llm(
     if llm is None:
         raise Exception(f"初始化原始LLM实例失败：{model}")
 
-    # 如果不需要结构化输出包装，直接返回原始 LLM（仍保留日志和 Langfuse 跟踪）
+    # 如果不需要结构化输出包装，返回带 Token 统计的包装类
     if not wrap_structured:
-        return llm
+        return LLMWithTokenTracking(llm, langfuse, llmConfig)
 
     # 获取kwargs中summary_prompt参数
     summary_prompt: str = kwargs.get("summary_prompt")
 
-    return LLMWithAutoTokenUsage(llm, langfuse, llmConfig, summary_prompt, max_retries=max_retries)
+    return LLMWithAutoTokenUsage(
+        llm, langfuse, llmConfig, summary_prompt,
+        max_retries=max_retries
+    )

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/src/sycommon/llm/struct_token.py

@@ -1,19 +1,25 @@
-import tiktoken
-from typing import Dict, List, Optional, Any
-from langfuse import Langfuse, LangfuseSpan, propagate_attributes
-from sycommon.llm.llm_logger import LLMLogger
-from langchain_core.runnables import Runnable, RunnableConfig
-from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
-from sycommon.llm.llm_tokens import TokensCallbackHandler
-from sycommon.logging.kafka_log import SYLogger
-from sycommon.config.LLMConfig import LLMConfig
-from sycommon.tools.env import get_env_var
 from sycommon.tools.merge_headers import get_header_value
+from sycommon.tools.env import get_env_var
+from sycommon.config.LLMConfig import LLMConfig
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.llm.llm_tokens import TokensCallbackHandler
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
+from langchain_core.runnables import Runnable, RunnableConfig
+from sycommon.llm.llm_logger import LLMLogger
+from langfuse import Langfuse, LangfuseSpan, propagate_attributes
+from typing import Dict, List, Optional, Any
+import tiktoken
+import warnings
+warnings.filterwarnings("ignore", message="Pydantic serializer warnings")
 
 
 class StructuredRunnableWithToken(Runnable):
     """
     统一功能 Runnable：Trace追踪 + Token统计 + 自动上下文压缩
+
+    支持两种模式：
+    1. 兼容模式（is_native_mode=False）：retry_chain 期望输入 {"messages": [...]}
+    2. 原生模式（is_native_mode=True）：retry_chain 直接接收消息列表
     """
 
     def __init__(
@@ -26,7 +32,8 @@ class StructuredRunnableWithToken(Runnable):
         enable_compression: bool = True,
         threshold_ratio: float = 0.8,
         keep_last_n: int = 2,
-        max_compression_attempts: int = 5
+        max_compression_attempts: int = 5,
+        is_native_mode: bool = False
     ):
         super().__init__()
         self.retry_chain = retry_chain
@@ -38,6 +45,7 @@ class StructuredRunnableWithToken(Runnable):
         self.threshold_ratio = threshold_ratio
         self.keep_last_n = keep_last_n  # 保留最近N条消息不压缩
         self.max_compression_attempts = max_compression_attempts  # 最大压缩尝试次数
+        self.is_native_mode = is_native_mode  # 是否为原生模式
 
         # 初始化 Tokenizer
         try:
@@ -80,7 +88,8 @@ class StructuredRunnableWithToken(Runnable):
         max_tokens = int(self.llmConfig.maxTokens * self.threshold_ratio)
         # 计算每批消息的压缩阈值：平均分配可用 token 空间
         # 预留给 system_msgs 和 keep_recent 的 token 空间
-        reserved_tokens = self._count_tokens(system_msgs) + self._count_tokens(conversation[-self.keep_last_n:])
+        reserved_tokens = self._count_tokens(
+            system_msgs) + self._count_tokens(conversation[-self.keep_last_n:])
         available_tokens = max_tokens - reserved_tokens
 
         current_messages = messages
@@ -162,7 +171,8 @@ class StructuredRunnableWithToken(Runnable):
 
         # 根据目标 token 计算压缩比例
         if target_tokens and original_tokens > 0:
-            compression_ratio = max(0.3, min(0.7, target_tokens / original_tokens))
+            compression_ratio = max(
+                0.3, min(0.7, target_tokens / original_tokens))
             ratio_text = f"{int(compression_ratio * 100)}%"
         else:
             compression_ratio = 0.5
@@ -331,7 +341,14 @@ class StructuredRunnableWithToken(Runnable):
             # 【同步模式下不建议触发压缩，因为压缩本身是异步调用 LLM】
             # 如果同步也要压缩，需要用 asyncio.run(...)，这里暂时保持原逻辑直接透传
             adapted_input = self._adapt_input(input)
-            input_data = {"messages": adapted_input}
+
+            # 根据模式选择输入格式
+            if self.is_native_mode:
+                # 原生模式：直接传递消息列表
+                input_data = adapted_input
+            else:
+                # 兼容模式：包装成 {"messages": [...]}
+                input_data = {"messages": adapted_input}
 
             if span:
                 span.update_trace(input=input_data)
@@ -382,7 +399,13 @@ class StructuredRunnableWithToken(Runnable):
                     # 执行压缩，替换 adapted_input
                     adapted_input = await self._acompress_context(adapted_input)
 
-            input_data = {"messages": adapted_input}
+            # 根据模式选择输入格式
+            if self.is_native_mode:
+                # 原生模式：直接传递消息列表
+                input_data = adapted_input
+            else:
+                # 兼容模式：包装成 {"messages": [...]}
+                input_data = {"messages": adapted_input}
 
             if span:
                 span.update_trace(input=input_data)

sycommon_python_lib-0.2.0b19/src/sycommon/llm/usage_token.py

@@ -0,0 +1,264 @@
+from typing import Type, List, Optional, Callable
+from langfuse import Langfuse
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, ValidationError, Field
+from sycommon.config.LLMConfig import LLMConfig
+from sycommon.llm.struct_token import StructuredRunnableWithToken
+
+
+class LLMWithTokenTracking(BaseChatModel):
+    """
+    带Token统计的LLM包装类（非结构化输出场景）
+    用于 wrap_structured=False 时的 Token 统计和 Langfuse 追踪
+
+    设计原则：最小化重写，只重写核心的 _generate 和 _agenerate
+    所有其他方法（invoke, ainvoke, batch, abatch, stream, astream）
+    都会自动通过 BaseChatModel 的默认实现调用这两个核心方法
+    """
+    llm: BaseChatModel = Field(default=None)
+    langfuse: Optional[Langfuse] = Field(default=None, exclude=True)
+    llmConfig: Optional[LLMConfig] = Field(default=None, exclude=True)
+
+    def __init__(self, llm: BaseChatModel, langfuse: Langfuse = None, llmConfig: LLMConfig = None, **kwargs):
+        super().__init__(llm=llm, langfuse=langfuse, llmConfig=llmConfig, **kwargs)
+
+    def _generate(self, messages, stop=None, run_manager=None, **kwargs):
+        """
+        同步生成 - 核心方法
+        BaseChatModel 的 invoke/batch/stream 最终都会调用此方法
+        """
+        result = self.llm._generate(
+            messages, stop=stop, run_manager=run_manager, **kwargs)
+        return self._inject_token_usage(result)
+
+    async def _agenerate(self, messages, stop=None, run_manager=None, **kwargs):
+        """
+        异步生成 - 核心方法
+        BaseChatModel 的 ainvoke/abatch/astream 最终都会调用此方法
+        """
+        result = await self.llm._agenerate(messages, stop=stop, run_manager=run_manager, **kwargs)
+        return self._inject_token_usage(result)
+
+    def _inject_token_usage(self, result):
+        """
+        从 LLM 结果中提取 Token 统计并注入到响应消息中
+        支持单条和多条 generations
+        """
+        try:
+            if hasattr(result, 'generations') and result.generations:
+                for gen_group in result.generations:
+                    for generation in gen_group:
+                        if hasattr(generation, 'message') and generation.message:
+                            # 优先从 generation_info 获取
+                            if hasattr(generation, 'generation_info') and generation.generation_info:
+                                gen_info = generation.generation_info
+                                usage = {
+                                    "input_tokens": gen_info.get('input_tokens', gen_info.get('prompt_tokens', 0)),
+                                    "output_tokens": gen_info.get('output_tokens', gen_info.get('completion_tokens', 0)),
+                                    "total_tokens": gen_info.get('total_tokens', 0)
+                                }
+                                generation.message._token_usage_ = usage
+                            # 从 llm_output 获取（部分模型）
+                            elif hasattr(result, 'llm_output') and result.llm_output:
+                                llm_output = result.llm_output
+                                if 'token_usage' in llm_output:
+                                    token_usage = llm_output['token_usage']
+                                    usage = {
+                                        "input_tokens": token_usage.get('prompt_tokens', token_usage.get('input_tokens', 0)),
+                                        "output_tokens": token_usage.get('completion_tokens', token_usage.get('output_tokens', 0)),
+                                        "total_tokens": token_usage.get('total_tokens', 0)
+                                    }
+                                    generation.message._token_usage_ = usage
+        except Exception as e:
+            from sycommon.logging.kafka_log import SYLogger
+            SYLogger.warning(f"Token 统计注入失败: {str(e)}")
+
+        return result
+
+    @property
+    def _llm_type(self) -> str:
+        return self.llm._llm_type
+
+    def __getattr__(self, name):
+        """代理所有其他属性到原始 llm（如 model_name, max_tokens, with_structured_output 等）"""
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            return getattr(self.llm, name)
+
+
+class LLMWithAutoTokenUsage(BaseChatModel):
+    """自动为结构化调用返回token_usage的LLM包装类"""
+    llm: BaseChatModel = Field(default=None)
+    langfuse: Optional[Langfuse] = Field(default=None, exclude=True)
+    llmConfig: Optional[LLMConfig] = Field(default=None, exclude=True)
+    summary_prompt: Optional[str] = Field(default=None, exclude=True)
+    max_retries: int = Field(default=3, exclude=True)
+
+    def __init__(self, llm: BaseChatModel, langfuse: Langfuse, llmConfig: LLMConfig, summary_prompt: str, max_retries: int = 3, **kwargs):
+        super().__init__(llm=llm, langfuse=langfuse, llmConfig=llmConfig,
+                         summary_prompt=summary_prompt, max_retries=max_retries, **kwargs)
+
+    def with_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int = None,
+        is_extract: bool = False,
+        override_prompt: ChatPromptTemplate = None,
+        custom_processors: Optional[List[Callable[[str], str]]] = None,
+        custom_parser: Optional[Callable[[str], BaseModel]] = None,
+        use_native: bool = None  # True/None: 原生模式(默认), False: 兼容模式
+    ) -> Runnable:
+        """
+        返回支持自动统计Token的结构化Runnable
+
+        Args:
+            output_model: Pydantic 模型
+            max_retries: 最大重试次数
+            is_extract: 是否为提取模式
+            override_prompt: 自定义提示词模板
+            custom_processors: 自定义文本处理器
+            custom_parser: 自定义解析器
+            use_native: 是否使用原生结构化输出（默认True）
+                - True/None: 使用原生模式（推荐）
+                - False: 使用兼容模式（仅用于不支持原生的旧模型）
+        """
+        # 使用实例的max_retries作为默认值
+        if max_retries is None:
+            max_retries = self.max_retries
+
+        # 默认使用原生模式，仅当显式指定 False 时才使用兼容模式
+        if use_native is False:
+            return self._with_compatible_structured_output(
+                output_model, max_retries, is_extract, override_prompt, custom_processors, custom_parser
+            )
+        else:
+            return self._with_native_structured_output(output_model, max_retries)
+
+    def _with_native_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int
+    ) -> Runnable:
+        """
+        使用模型原生的 with_structured_output 方法
+        适用于：Qwen3.5-122B-A10B 等原生支持的模型
+        """
+        # 调用原生方法
+        native_runnable = self.llm.with_structured_output(output_model)
+
+        # 包装为支持 Token 统计和 Langfuse 追踪的 Runnable
+        return StructuredRunnableWithToken(
+            retry_chain=native_runnable,
+            langfuse=self.langfuse,
+            llmConfig=self.llmConfig,
+            summary_prompt=self.summary_prompt,
+            model_name=self.llmConfig.model if self.llmConfig else "Qwen2.5-72B",
+            is_native_mode=True
+        )
+
+    def _with_compatible_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int,
+        is_extract: bool,
+        override_prompt: ChatPromptTemplate,
+        custom_processors: Optional[List[Callable[[str], str]]],
+        custom_parser: Optional[Callable[[str], BaseModel]]
+    ) -> Runnable:
+        """
+        使用兼容模式（手动解析 JSON）
+        适用于：不支持原生结构化输出的模型
+        """
+        parser = PydanticOutputParser(pydantic_object=output_model)
+
+        # 提示词模板
+        accuracy_instructions = """
+        字段值的抽取准确率（0~1之间），评分规则：
+        1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
+        0.9（轻微处理）：数据来源明确，但需进行格式标准化或冗余信息剔除（不改变原始数值）
+        0.8（有限推断）：数据需通过上下文关联或简单计算得出，仍有明确依据
+        0.8以下（不可靠）：数据需大量推测、存在歧义或来源不明，处理方式：直接忽略该数据，设置为None
+        """
+
+        if is_extract:
+            prompt = ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                请提取信息并遵循以下规则：
+                1. 准确率要求：{accuracy_instructions.strip()}
+                2. 输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+        else:
+            prompt = override_prompt or ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+
+        # 文本处理函数
+        def extract_response_content(response: BaseMessage) -> str:
+            try:
+                return response.content
+            except Exception as e:
+                raise ValueError(f"提取响应内容失败：{str(e)}") from e
+
+        def strip_code_block_markers(content: str) -> str:
+            try:
+                return content.strip("```json").strip("```").strip()
+            except Exception as e:
+                raise ValueError(f"移除代码块标记失败：{str(e)}") from e
+
+        def normalize_in_json(content: str) -> str:
+            try:
+                return content.replace("None", "null").replace("none", "null").replace("NONE", "null").replace("''", '""')
+            except Exception as e:
+                raise ValueError(f"JSON格式化失败：{str(e)}") from e
+
+        def default_parse_to_pydantic(content: str) -> BaseModel:
+            try:
+                return parser.parse(content)
+            except (ValidationError, ValueError) as e:
+                raise ValueError(f"解析结构化结果失败：{str(e)}") from e
+
+        # ========== 构建处理链 ==========
+        base_chain = prompt | self.llm | RunnableLambda(
+            extract_response_content)
+
+        # 文本处理链
+        process_runnables = custom_processors or [
+            RunnableLambda(strip_code_block_markers),
+            RunnableLambda(normalize_in_json)
+        ]
+        process_chain = base_chain
+        for runnable in process_runnables:
+            process_chain = process_chain | runnable
+
+        # 解析链
+        parse_chain = process_chain | RunnableLambda(
+            custom_parser or default_parse_to_pydantic)
+
+        # 重试链
+        retry_chain = parse_chain.with_retry(
+            retry_if_exception_type=(ValidationError, ValueError),
+            stop_after_attempt=max_retries,
+            wait_exponential_jitter=True,
+            exponential_jitter_params={
+                "initial": 0.1, "max": 3.0, "exp_base": 2.0, "jitter": 1.0}
+        )
+
+        return StructuredRunnableWithToken(retry_chain, self.langfuse, self.llmConfig, self.summary_prompt)
+
+    # ========== 实现BaseChatModel抽象方法 ==========
+    def _generate(self, messages, stop=None, run_manager=None, ** kwargs):
+        return self.llm._generate(messages, stop=stop, run_manager=run_manager, ** kwargs)
+
+    @property
+    def _llm_type(self) -> str:
+        return self.llm._llm_type

{sycommon_python_lib-0.2.0b17 → sycommon_python_lib-0.2.0b19}/src/sycommon/notice/uvicorn_monitor.py

@@ -9,6 +9,46 @@ from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
 
 
+def get_webhook() -> Optional[str]:
+    """
+    获取企业微信 WebHook 配置
+
+    支持两种配置格式：
+    1. 字符串格式（旧版）：
+       llm:
+         WebHook: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+
+    2. 对象格式（新版，支持启用开关）：
+       llm:
+         WebHook:
+           enabled: true
+           url: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+    """
+    try:
+        config = Config().config
+        webhook_config = config.get('llm', {}).get('WebHook')
+
+        if webhook_config is None:
+            return None
+
+        # 字符串格式（旧版兼容）
+        if isinstance(webhook_config, str):
+            return webhook_config
+
+        # 对象格式（新版）
+        if isinstance(webhook_config, dict):
+            # 检查是否启用
+            if not webhook_config.get('enabled', True):
+                SYLogger.debug("企业微信 WebHook 已禁用")
+                return None
+            return webhook_config.get('url')
+
+        return None
+    except Exception as e:
+        SYLogger.warning(f"读取 WebHook 配置失败: {str(e)}")
+        return None
+
+
 async def send_wechat_markdown_msg(
     content: str,
     webhook: str = None
@@ -55,8 +95,7 @@ async def send_webhook(error_info: dict = None, webhook: str = None):
         config = Config().config
         service_name = config.get('Name', "未知服务")
         env = config.get('Nacos', {}).get('namespaceId', '未知环境')
-        # 注意：这里使用了大写开头的 WebHook，请确保配置文件中键名一致
-        webHook = config.get('llm', {}).get('WebHook')
+        webHook = get_webhook()
     except Exception as e:
         service_name = "未知服务"
         env = "未知环境"
@@ -186,3 +225,122 @@ def run(*args, webhook: str = None, **kwargs):
 
             # 只有确实有错误时才以状态码 1 退出
             sys.exit(1)
+
+
+async def send_mq_disconnect_alert(
+    error_msg: str,
+    host: str = None,
+    app_name: str = None,
+    disconnect_count: int = 0,
+    reconnect_attempts: int = 0,
+    is_recovered: bool = False
+) -> Optional[dict]:
+    """
+    发送 MQ 连接断开告警
+
+    :param error_msg: 错误信息
+    :param host: RabbitMQ 主机地址
+    :param app_name: 应用名称（MQ连接名）
+    :param disconnect_count: 累计断开次数
+    :param reconnect_attempts: 重连尝试次数
+    :param is_recovered: 是否已恢复
+    :return: 发送结果
+    """
+    try:
+        config = Config().config
+        service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+    except Exception:
+        service_name = "未知服务"
+        env = "未知环境"
+
+    webhook = get_webhook()
+    if not webhook:
+        SYLogger.debug("未配置企业微信 WebHook，跳过 MQ 断连告警")
+        return None
+
+    alert_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    # 显示服务名和应用名
+    display_name = f"{service_name}" + (f" ({app_name})" if app_name else "")
+
+    if is_recovered:
+        # 恢复通知
+        markdown_content = f"""### {display_name} RabbitMQ 连接已恢复 ✅
+> 环境: <font color="info">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 节点: <font color="comment">{host or '未知'}</font>
+> 恢复前重试次数: {reconnect_attempts}
+> 本次断开次数: {disconnect_count}"""
+    else:
+        # 断开告警
+        markdown_content = f"""### {display_name} RabbitMQ 连接断开告警 🚨
+> 环境: <font color="warning">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 节点: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: <font color="danger">{disconnect_count}</font>
+> 重连尝试: {reconnect_attempts} 次
+> 错误信息: <font color="danger">{error_msg}</font>"""
+
+    return await send_wechat_markdown_msg(
+        content=markdown_content,
+        webhook=webhook
+    )
+
+
+async def send_nacos_disconnect_alert(
+    error_msg: str,
+    service_name: str = None,
+    host: str = None,
+    disconnect_count: int = 0,
+    fail_count: int = 0,
+    is_recovered: bool = False
+) -> Optional[dict]:
+    """
+    发送 Nacos 连接断开告警
+
+    :param error_msg: 错误信息
+    :param service_name: 服务名称
+    :param host: 服务地址
+    :param disconnect_count: 累计断开次数
+    :param fail_count: 连续失败次数
+    :param is_recovered: 是否已恢复
+    :return: 发送结果
+    """
+    try:
+        config = Config().config
+        display_service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+    except Exception:
+        display_service_name = "未知服务"
+        env = "未知环境"
+
+    webhook = get_webhook()
+    if not webhook:
+        SYLogger.debug("未配置企业微信 WebHook，跳过 Nacos 断连告警")
+        return None
+
+    alert_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    # 显示服务名
+    display_name = service_name or display_service_name
+
+    if is_recovered:
+        # 恢复通知
+        markdown_content = f"""### {display_name} Nacos 心跳已恢复 ✅
+> 环境: <font color="info">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 服务地址: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: {disconnect_count}"""
+    else:
+        # 断开告警
+        markdown_content = f"""### {display_name} Nacos 心跳失败告警 🚨
+> 环境: <font color="warning">{env}</font>
+> 时间: <font color="comment">{alert_time}</font>
+> 服务地址: <font color="comment">{host or '未知'}</font>
+> 累计断开次数: <font color="danger">{disconnect_count}</font>
+> 连续失败: {fail_count} 次
+> 错误信息: <font color="danger">{error_msg}</font>"""
+
+    return await send_wechat_markdown_msg(
+        content=markdown_content,
+        webhook=webhook
+    )