sycommon-python-lib 0.2.0b30__tar.gz → 0.2.0b32__tar.gz

{sycommon_python_lib-0.2.0b30 → sycommon_python_lib-0.2.0b32}/PKG-INFO

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

{sycommon_python_lib-0.2.0b30 → sycommon_python_lib-0.2.0b32}/pyproject.toml

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

{sycommon_python_lib-0.2.0b30 → sycommon_python_lib-0.2.0b32}/src/sycommon/llm/get_llm.py

@@ -59,9 +59,15 @@ def get_llm(
         # 指令模式（默认）
         llm = get_llm("Qwen3.5-122B-A10B", thinking=False)
 
-        # 结构化输出
+        # 结构化输出 - 默认模式（推荐）
+        # use_native=False（默认）：使用 OutputFixingRunnable，更稳定
         llm = get_llm("Qwen3.5-122B-A10B")
-        chain = llm.with_structured_output(MyModel)
+        chain = llm.with_structured_output(MyModel)  # use_native=False 默认
+        result = await chain.ainvoke([HumanMessage(content="你好")])
+
+        # 使用原生模式（需模型支持 function calling）
+        llm = get_llm("Qwen3.5-122B-A10B")
+        chain = llm.with_structured_output(MyModel, use_native=True)
         result = await chain.ainvoke([HumanMessage(content="你好")])
         print(result._token_usage_)  # Token 统计
 
@@ -146,6 +152,7 @@ def get_llm(
         "streaming": streaming,
         "timeout": timeout,
         "max_retries": max_retries,
+        "model_kwargs": {"response_format": {"type": "json_object"}},
     }
 
     # 合并其他透传参数（包括 presence_penalty, extra_body, top_p 等）

sycommon_python_lib-0.2.0b32/src/sycommon/llm/native_with_fallback_runnable.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+"""
+原生模式 + 降级修正 Runnable
+
+第一次使用原生 with_structured_output，失败后降级到修正逻辑。
+"""
+
+import json
+import re
+from typing import Type, Optional, Any
+
+from pydantic import BaseModel, ValidationError
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import HumanMessage
+
+
+class NativeWithFallbackRunnable(Runnable):
+    """
+    原生模式 + 降级修正 Runnable
+
+    第一次使用原生 with_structured_output，失败后降级到修正逻辑。
+    """
+
+    def __init__(
+        self,
+        native_runnable: Runnable,
+        llm: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3
+    ):
+        super().__init__()
+        self.native_runnable = native_runnable
+        self.llm = llm
+        self.output_model = output_model
+        self.max_retries = max_retries
+        self.parser = PydanticOutputParser(pydantic_object=output_model)
+
+    def _try_parse_result(self, result) -> BaseModel:
+        """尝试将结果转换为 Pydantic 模型"""
+        if isinstance(result, self.output_model):
+            return result
+
+        if isinstance(result, dict):
+            return self.output_model(**result)
+
+        if isinstance(result, str):
+            processed = self._process_content(result)
+            data = json.loads(processed)
+            return self.output_model(**data)
+
+        raise ValueError(f"无法将结果转换为 {self.output_model.__name__}")
+
+    def _process_content(self, content: str) -> str:
+        """处理内容"""
+        content = content.strip("```json").strip("```").strip()
+        json_match = re.search(r'\{[\s\S]*\}', content)
+        if json_match:
+            content = json_match.group(0)
+        content = content.replace("None", "null").replace("none", "null").replace("NONE", "null")
+        content = content.replace('"', '"').replace('"', '"')
+        return content
+
+    def _extract_content(self, response) -> str:
+        """从 LLM 响应中提取文本内容"""
+        if hasattr(response, 'content'):
+            return response.content
+        return str(response)
+
+    def _request_fix(self, messages: list, failed_output: str, error_message: str, config=None) -> str:
+        """请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+        response = self.llm.invoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    async def _arequest_fix(self, messages: list, failed_output: str, error_message: str, config=None) -> str:
+        """异步请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+        response = await self.llm.ainvoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """同步调用"""
+        messages = input if isinstance(input, list) else input.get("messages", [])
+        last_error = None
+        last_content = None
+
+        for attempt in range(self.max_retries):
+            try:
+                if attempt == 0:
+                    # 第一次：使用原生 runnable
+                    result = self.native_runnable.invoke(input, config=config)
+                    return self._try_parse_result(result)
+                else:
+                    # 修正模式
+                    from sycommon.logging.kafka_log import SYLogger
+                    SYLogger.warning(f"[Native降级修正] 第 {attempt} 次尝试，错误: {last_error}")
+
+                    last_content = self._request_fix(
+                        messages, last_content or "", str(last_error), config
+                    )
+                    processed = self._process_content(last_content)
+                    try:
+                        result = self.parser.parse(processed)
+                        return result
+                    except Exception:
+                        data = json.loads(processed)
+                        return self.output_model(**data)
+
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                if attempt == 0:
+                    try:
+                        last_content = str(result) if 'result' in dir() else ""
+                    except:
+                        last_content = ""
+                    SYLogger.warning(f"[Native降级修正] 原生模式失败，降级到修正模式: {e}")
+
+                if attempt == self.max_retries - 1:
+                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+        raise ValueError("未知错误")
+
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """异步调用"""
+        messages = input if isinstance(input, list) else input.get("messages", [])
+        last_error = None
+        last_content = None
+
+        for attempt in range(self.max_retries):
+            try:
+                if attempt == 0:
+                    # 第一次：使用原生 runnable
+                    result = await self.native_runnable.ainvoke(input, config=config)
+                    return self._try_parse_result(result)
+                else:
+                    # 修正模式
+                    from sycommon.logging.kafka_log import SYLogger
+                    SYLogger.warning(f"[Native降级修正] 第 {attempt} 次尝试，错误: {last_error}")
+
+                    last_content = await self._arequest_fix(
+                        messages, last_content or "", str(last_error), config
+                    )
+                    processed = self._process_content(last_content)
+                    try:
+                        result = self.parser.parse(processed)
+                        return result
+                    except Exception:
+                        data = json.loads(processed)
+                        return self.output_model(**data)
+
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                if attempt == 0:
+                    try:
+                        last_content = str(result) if 'result' in dir() else ""
+                    except:
+                        last_content = ""
+                    SYLogger.warning(f"[Native降级修正] 原生模式失败，降级到修正模式: {e}")
+
+                if attempt == self.max_retries - 1:
+                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+        raise ValueError("未知错误")

sycommon_python_lib-0.2.0b32/src/sycommon/llm/output_fixing_runnable.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+结构化输出自动修正 Runnable
+
+当 JSON 解析失败时，自动将错误信息和原始输出发送给 LLM 请求修正。
+类似于 LangChain 旧版的 OutputFixingParser 功能。
+"""
+
+import json
+import re
+from typing import Type, Optional, Any
+
+from pydantic import BaseModel, ValidationError
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import HumanMessage
+
+
+class OutputFixingRunnable(Runnable):
+    """
+    结构化输出自动修正 Runnable
+
+    特点：
+    - 当解析失败时，自动将错误信息和原始输出发送给 LLM 请求修正
+    - 支持自定义最大重试次数
+    - 自动处理常见的 JSON 格式问题（中文引号、代码块标记等）
+
+    适用场景：
+    - 输出偶尔格式错误
+    - 需要稳定可靠的 JSON 解析
+    """
+
+    def __init__(
+        self,
+        base_chain: Runnable,
+        llm: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3
+    ):
+        super().__init__()
+        self.base_chain = base_chain
+        self.llm = llm
+        self.output_model = output_model
+        self.max_retries = max_retries
+        self.parser = PydanticOutputParser(pydantic_object=output_model)
+
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """同步调用"""
+        # 获取 LLM 响应（通过 base_chain，包含 prompt）
+        response = self.base_chain.invoke(input, config=config)
+        content = self._extract_content(response)
+
+        last_error = None
+        last_content = content
+
+        for attempt in range(self.max_retries):
+            try:
+                # 处理内容并尝试解析
+                processed = self._process_content(last_content)
+                # 先尝试直接用 PydanticOutputParser 解析
+                try:
+                    result = self.parser.parse(processed)
+                    return result
+                except Exception:
+                    # 如果失败，尝试用 json.loads 解析后再实例化
+                    data = json.loads(processed)
+                    result = self.output_model(**data)
+                    return result
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                SYLogger.warning(f"[OutputFixing] 第 {attempt + 1} 次解析失败: {e}")
+
+                if attempt < self.max_retries - 1:
+                    # 请求 LLM 修正
+                    last_content = self._request_fix(
+                        original_input=input,
+                        failed_output=last_content,
+                        error_message=str(e),
+                        config=config
+                    )
+
+        raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """异步调用"""
+        # 获取 LLM 响应（通过 base_chain，包含 prompt）
+        response = await self.base_chain.ainvoke(input, config=config)
+        content = self._extract_content(response)
+
+        last_error = None
+        last_content = content
+
+        for attempt in range(self.max_retries):
+            try:
+                # 处理内容并尝试解析
+                processed = self._process_content(last_content)
+                # 先尝试直接用 PydanticOutputParser 解析
+                try:
+                    result = self.parser.parse(processed)
+                    return result
+                except Exception:
+                    # 如果失败，尝试用 json.loads 解析后再实例化
+                    data = json.loads(processed)
+                    result = self.output_model(**data)
+                    return result
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                SYLogger.warning(f"[OutputFixing] 第 {attempt + 1} 次解析失败: {e}")
+
+                if attempt < self.max_retries - 1:
+                    # 请求 LLM 修正
+                    last_content = await self._arequest_fix(
+                        original_input=input,
+                        failed_output=last_content,
+                        error_message=str(e),
+                        config=config
+                    )
+
+        raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+    def _extract_content(self, response) -> str:
+        """从 LLM 响应中提取文本内容"""
+        if hasattr(response, 'content'):
+            return response.content
+        return str(response)
+
+    def _process_content(self, content: str) -> str:
+        """处理内容（移除代码块标记、规范化 JSON）"""
+        # 移除 markdown 代码块标记
+        content = content.strip("```json").strip("```").strip()
+
+        # 尝试提取 JSON 对象（处理前后有多余文本的情况）
+        json_match = re.search(r'\{[\s\S]*\}', content)
+        if json_match:
+            content = json_match.group(0)
+
+        # 规范化 null 值
+        content = content.replace("None", "null").replace(
+            "none", "null").replace("NONE", "null")
+
+        # 规范化中文引号为英文引号（只处理键和字符串值外部的引号）
+        content = content.replace('"', '"').replace('"', '"')
+
+        # 处理单引号（谨慎处理，只替换明显不是内容中的单引号）
+        # 不再简单替换所有单引号为双引号，因为这可能破坏内容
+
+        return content
+
+    def _request_fix(
+        self,
+        original_input: Any,
+        failed_output: str,
+        error_message: str,
+        config: Optional[RunnableConfig] = None
+    ) -> str:
+        """请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        # 提取原始消息
+        messages = original_input.get("messages", []) if isinstance(
+            original_input, dict) else []
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+
+        response = self.llm.invoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    async def _arequest_fix(
+        self,
+        original_input: Any,
+        failed_output: str,
+        error_message: str,
+        config: Optional[RunnableConfig] = None
+    ) -> str:
+        """异步请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        # 提取原始消息
+        messages = original_input.get("messages", []) if isinstance(
+            original_input, dict) else []
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+
+        response = await self.llm.ainvoke(fix_messages, config=config)
+        return self._extract_content(response)

{sycommon_python_lib-0.2.0b30 → sycommon_python_lib-0.2.0b32}/src/sycommon/llm/token_usage_mysql_service.py

@@ -101,7 +101,7 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                 # 创建表（如果不存在）
                 await session.execute(text(f"""
                     CREATE TABLE IF NOT EXISTS token_usage_daily (
-                        id INT AUTO_INCREMENT PRIMARY KEY,
+                        id INT AUTO_INCREMENT PRIMARY KEY COMMENT '主键ID',
                         user_id VARCHAR(128) NULL COMMENT '用户ID',
                         tenant_id VARCHAR(128) NULL COMMENT '租户ID',
                         service_name VARCHAR(128) NULL COMMENT '服务名称',
@@ -113,7 +113,7 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                         usage_date DATE NOT NULL COMMENT '使用日期',
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
-                        UNIQUE KEY uq_user_service_env_date (user_id, service_name, system_env, usage_date),
+                        UNIQUE KEY uniq_user_service_env_date (user_id, service_name, system_env, usage_date),
                         INDEX idx_user_id (user_id),
                         INDEX idx_service_name (service_name),
                         INDEX idx_tenant_id (tenant_id),

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

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+"""
+LLM Token 统计和结构化输出模块
+
+支持两种结构化输出模式：
+1. native: 使用模型原生的 with_structured_output，失败后降级到修正逻辑
+2. fixing: 直接使用 OutputFixingRunnable（默认模式，更稳定）
+"""
+
+from typing import Type, Optional
+
+from langfuse import Langfuse
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, Field
+
+from sycommon.config.LLMConfig import LLMConfig
+from sycommon.llm.struct_token import StructuredRunnableWithToken
+from sycommon.llm.output_fixing_runnable import OutputFixingRunnable
+from sycommon.llm.native_with_fallback_runnable import NativeWithFallbackRunnable
+
+
+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,
+        use_native: bool = False
+    ) -> Runnable:
+        """
+        返回支持自动统计Token的结构化Runnable
+
+        Args:
+            output_model: Pydantic 模型
+            max_retries: 最大重试次数
+            is_extract: 是否为提取模式
+            override_prompt: 自定义提示词模板
+            use_native: 是否使用原生结构化输出（默认 False）
+                - False: 使用 OutputFixingRunnable（默认，更稳定）
+                - True: 使用原生 with_structured_output，失败后降级到修正模式
+
+        Returns:
+            Runnable: 支持结构化输出的 Runnable
+        """
+        if max_retries is None:
+            max_retries = self.max_retries
+
+        if use_native:
+            return self._with_native_structured_output(output_model, max_retries)
+        else:
+            return self._with_fixing_structured_output(
+                output_model, max_retries, is_extract, override_prompt
+            )
+
+    def _with_native_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int
+    ) -> Runnable:
+        """
+        原生模式 + 降级修正
+
+        第一次使用原生 with_structured_output，失败后降级到修正逻辑。
+        """
+        native_runnable = self.llm.with_structured_output(output_model)
+
+        native_chain = NativeWithFallbackRunnable(
+            native_runnable=native_runnable,
+            llm=self.llm,
+            output_model=output_model,
+            max_retries=max_retries
+        )
+
+        return StructuredRunnableWithToken(
+            retry_chain=native_chain,
+            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_fixing_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int,
+        is_extract: bool = False,
+        override_prompt: ChatPromptTemplate = None
+    ) -> Runnable:
+        """
+        使用 LangChain 内置 OutputFixingParser
+
+        特点：
+        - 当解析失败时，自动将错误信息和原始输出发送给 LLM 请求修正
+        - 使用官方维护的 OutputFixingParser，稳定性高
+        - 适用于输出偶尔格式错误的场景
+
+        适用场景：
+        - 输出偶尔格式错误
+        - 需要稳定可靠的 JSON 解析
+        - 模型不支持原生 function calling
+        """
+        parser = PydanticOutputParser(pydantic_object=output_model)
+
+        # 提示词模板
+        if is_extract:
+            accuracy_instructions = """
+            字段值的抽取准确率（0~1之间），评分规则：
+            1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
+            0.9（轻微处理）：数据来源明确，但需进行格式标准化或冗余信息剔除（不改变原始数值）
+            0.8（有限推断）：数据需通过上下文关联或简单计算得出，仍有明确依据
+            0.8以下（不可靠）：数据需大量推测、存在歧义或来源不明，处理方式：直接忽略该数据，设置为None
+            """
+            prompt = ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                请提取信息并遵循以下规则：
+                1. 准确率要求：{accuracy_instructions.strip()}
+                2. 输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：{parser.get_format_instructions()}
+                """)
+            ])
+        else:
+            prompt = override_prompt or ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：{parser.get_format_instructions()}
+                """)
+            ])
+
+        # 构建 LLM 调用链
+        chain = prompt | self.llm
+
+        # 使用 OutputFixingRunnable 包装
+        fixing_chain = OutputFixingRunnable(
+            base_chain=chain,
+            llm=self.llm,
+            output_model=output_model,
+            max_retries=max_retries
+        )
+
+        # 包装为支持 Token 统计和 Langfuse 追踪的 Runnable
+        return StructuredRunnableWithToken(
+            retry_chain=fixing_chain,
+            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=False
+        )
+
+    # ========== 实现BaseChatModel抽象方法 ==========
+    def _generate(self, messages, stop=None, run_manager=None, **kwargs):
+        return self.llm._generate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    async def _agenerate(self, messages, stop=None, run_manager=None, **kwargs):
+        """异步生成 - 委托给底层 LLM"""
+        return await self.llm._agenerate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    def _stream(self, messages, stop=None, run_manager=None, **kwargs):
+        """流式生成 - 委托给底层 LLM"""
+        yield from self.llm._stream(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    async def _astream(self, messages, stop=None, run_manager=None, **kwargs):
+        """异步流式生成 - 委托给底层 LLM"""
+        async for chunk in self.llm._astream(messages, stop=stop, run_manager=run_manager, **kwargs):
+            yield chunk
+
+    @property
+    def _llm_type(self) -> str:
+        return self.llm._llm_type

{sycommon_python_lib-0.2.0b30 → sycommon_python_lib-0.2.0b32}/src/sycommon/models/token_usage_mysql.py

@@ -21,7 +21,7 @@ class TokenUsageMySQL(Base):
     __tablename__ = "token_usage_daily"
 
     # 主键
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="主键ID")
 
     # 业务字段
     user_id: Mapped[Optional[str]] = mapped_column(String(128), nullable=True, comment="用户ID")
@@ -46,7 +46,7 @@ class TokenUsageMySQL(Base):
 
     # 联合唯一索引：用户+服务名+环境+日期
     __table_args__ = (
-        UniqueConstraint('user_id', 'service_name', 'system_env', 'usage_date', name='uq_user_service_env_date'),
+        UniqueConstraint('user_id', 'service_name', 'system_env', 'usage_date', name='uniq_user_service_env_date'),
         Index('idx_user_id', 'user_id'),
         Index('idx_service_name', 'service_name'),
         Index('idx_tenant_id', 'tenant_id'),