feat：添加术语推断和术语理解

src/common/database/database_model.py

@@ -358,6 +358,9 @@ class Jargon(BaseModel):
     chat_id = TextField(index=True)
     is_global = BooleanField(default=False)
     count = IntegerField(default=0)
+    is_jargon = BooleanField(null=True)  # None表示未判定，True表示是黑话，False表示不是黑话
+    last_inference_count = IntegerField(null=True)  # 最后一次判定的count值，用于避免重启后重复判定
+    is_complete = BooleanField(default=False)  # 是否已完成所有推断（count>=100后不再推断）
     
     class Meta:
         table_name = "jargon"

src/jargon/jargon_miner.py

@@ -1,5 +1,6 @@
 import time
 import json
+import asyncio
 from typing import List
 from json_repair import repair_json
 
@@ -26,20 +27,22 @@ def _init_prompt() -> None:
 请从上面这段聊天内容中提取"可能是黑话"的候选项（黑话/俚语/网络缩写/口头禅）。
 - 必须为对话中真实出现过的短词或短语
 - 必须是你无法理解含义的词语，或者出现频率较高的词语
-- 必须是这几种类别之一：英文或中文缩写、中文拼音短语、字母数字混合、意义不明但频繁的词汇
+- 请不要选择有明确含义，或者含义清晰的词语
+- 必须是这几种类别之一：英文或中文缩写、中文拼音短语、字母数字混合
 - 排除：人名、@、明显的表情/图片占位、纯标点、常规功能词（如的、了、呢、啊等）
 - 每个词条长度建议 2-8 个字符（不强制），尽量短小
 - 合并重复项，去重
 
-分类规则：
-- p（拼音缩写）：由字母或字母和汉字构成的，疑似拼音简写词，例如：nb、yyds、xswl
+分类规则,type必须根据规则填写：
+- p（拼音缩写）：由字母或字母和汉字构成的，用汉语拼音简写词，或汉语拼音首字母的简写词，例如：nb、yyds、xswl
 - c（中文缩写）：中文词语的缩写，用几个汉字概括一个词汇或含义，例如：社死、内卷
 - e（英文缩写）：英文词语的缩写，用英文字母概括一个词汇或含义，例如：CPU、GPU、API
+- x（谐音梗）：谐音梗，用谐音词概括一个词汇或含义，例如：好似，难崩
 
 以 JSON 数组输出，元素为对象（严格按以下结构）：
 [
-  {{"content": "词条", "raw_content": "包含该词条的完整句子", "type": "p"}},
-  {{"content": "词条2", "raw_content": "包含该词条的完整句子", "type": "c"}}
+  {{"content": "词条", "raw_content": "包含该词条的完整对话原文", "type": "p"}},
+  {{"content": "词条2", "raw_content": "包含该词条的完整对话原文", "type": "c"}}
 ]
 
 现在请输出：
@@ -47,7 +50,107 @@ def _init_prompt() -> None:
     Prompt(prompt_str, "extract_jargon_prompt")
 
 
+def _init_inference_prompts() -> None:
+    """初始化含义推断相关的prompt"""
+    # Prompt 1: 基于raw_content和content推断
+    prompt1_str = """
+**词条内容**
+{content}
+
+**词条出现的上下文（raw_content）**
+{raw_content_list}
+
+请根据以上词条内容和上下文，推断这个词条的含义。
+- 如果这是一个黑话、俚语或网络用语，请推断其含义和翻译
+- 如果含义明确（常规词汇），也请说明
+
+以 JSON 格式输出：
+{{
+  "meaning": "含义说明",
+  "translation": "翻译或解释"
+}}
+"""
+    Prompt(prompt1_str, "jargon_inference_with_context_prompt")
+
+    # Prompt 2: 仅基于content推断
+    prompt2_str = """
+**词条内容**
+{content}
+
+请仅根据这个词条本身，推断其含义。
+- 如果这是一个黑话、俚语或网络用语，请推断其含义和翻译
+- 如果含义明确（常规词汇），也请说明
+
+以 JSON 格式输出：
+{{
+  "meaning": "含义说明",
+  "translation": "翻译或解释"
+}}
+"""
+    Prompt(prompt2_str, "jargon_inference_content_only_prompt")
+
+    # Prompt 3: 比较两个推断结果
+    prompt3_str = """
+**推断结果1（基于上下文）**
+{inference1}
+
+**推断结果2（仅基于词条）**
+{inference2}
+
+请比较这两个推断结果，判断它们是否相同或类似。
+- 如果两个推断结果的"含义"相同或类似，说明这个词条不是黑话（含义明确）
+- 如果两个推断结果有差异，说明这个词条可能是黑话（需要上下文才能理解）
+
+以 JSON 格式输出：
+{{
+  "is_similar": true/false,
+  "reason": "判断理由"
+}}
+"""
+    Prompt(prompt3_str, "jargon_compare_inference_prompt")
+
+
 _init_prompt()
+_init_inference_prompts()
+
+
+def _should_infer_meaning(jargon_obj: Jargon) -> bool:
+    """
+    判断是否需要进行含义推断
+    在 count 达到 5, 10, 20, 40, 60, 100 时进行推断
+    并且count必须大于last_inference_count，避免重启后重复判定
+    如果is_complete为True，不再进行推断
+    """
+    # 如果已完成所有推断，不再推断
+    if jargon_obj.is_complete:
+        return False
+    
+    count = jargon_obj.count or 0
+    last_inference = jargon_obj.last_inference_count or 0
+    
+    # 阈值列表：5, 10, 20, 40, 60, 100
+    thresholds = [5, 10, 20, 40, 60, 100]
+    
+    if count < thresholds[0]:
+        return False
+    
+    # 如果count没有超过上次判定值，不需要判定
+    if count <= last_inference:
+        return False
+    
+    # 找到第一个大于last_inference的阈值
+    next_threshold = None
+    for threshold in thresholds:
+        if threshold > last_inference:
+            next_threshold = threshold
+            break
+    
+    # 如果没有找到下一个阈值，说明已经超过100，不应该再推断
+    if next_threshold is None:
+        return False
+    
+    # 检查count是否达到或超过这个阈值
+    return count >= next_threshold
 
 
 class JargonMiner:
@@ -63,6 +166,162 @@ class JargonMiner:
             request_type="jargon.extract",
         )
 
+    async def _infer_meaning_by_id(self, jargon_id: int) -> None:
+        """通过ID加载对象并推断"""
+        try:
+            jargon_obj = Jargon.get_by_id(jargon_id)
+            # 再次检查is_complete，因为可能在异步任务执行时已被标记为完成
+            if jargon_obj.is_complete:
+                logger.debug(f"jargon {jargon_obj.content} 已完成所有推断，跳过")
+                return
+            await self.infer_meaning(jargon_obj)
+        except Exception as e:
+            logger.error(f"通过ID推断jargon失败: {e}")
+
+    async def infer_meaning(self, jargon_obj: Jargon) -> None:
+        """
+        对jargon进行含义推断
+        """
+        try:
+            content = jargon_obj.content
+            raw_content_str = jargon_obj.raw_content or ""
+            
+            # 解析raw_content列表
+            raw_content_list = []
+            if raw_content_str:
+                try:
+                    raw_content_list = json.loads(raw_content_str) if isinstance(raw_content_str, str) else raw_content_str
+                    if not isinstance(raw_content_list, list):
+                        raw_content_list = [raw_content_list] if raw_content_list else []
+                except (json.JSONDecodeError, TypeError):
+                    raw_content_list = [raw_content_str] if raw_content_str else []
+            
+            if not raw_content_list:
+                logger.warning(f"jargon {content} 没有raw_content，跳过推断")
+                return
+
+            # 步骤1: 基于raw_content和content推断
+            raw_content_text = "\n".join(raw_content_list)
+            prompt1 = await global_prompt_manager.format_prompt(
+                "jargon_inference_with_context_prompt",
+                content=content,
+                raw_content_list=raw_content_text,
+            )
+            
+            response1, _ = await self.llm.generate_response_async(prompt1, temperature=0.3)
+            if not response1:
+                logger.warning(f"jargon {content} 推断1失败：无响应")
+                return
+            
+            # 解析推断1结果
+            inference1 = None
+            try:
+                resp1 = response1.strip()
+                if resp1.startswith("{") and resp1.endswith("}"):
+                    inference1 = json.loads(resp1)
+                else:
+                    repaired = repair_json(resp1)
+                    inference1 = json.loads(repaired) if isinstance(repaired, str) else repaired
+                if not isinstance(inference1, dict):
+                    logger.warning(f"jargon {content} 推断1结果格式错误")
+                    return
+            except Exception as e:
+                logger.error(f"jargon {content} 推断1解析失败: {e}")
+                return
+
+            # 步骤2: 仅基于content推断
+            prompt2 = await global_prompt_manager.format_prompt(
+                "jargon_inference_content_only_prompt",
+                content=content,
+            )
+            
+            response2, _ = await self.llm.generate_response_async(prompt2, temperature=0.3)
+            if not response2:
+                logger.warning(f"jargon {content} 推断2失败：无响应")
+                return
+            
+            # 解析推断2结果
+            inference2 = None
+            try:
+                resp2 = response2.strip()
+                if resp2.startswith("{") and resp2.endswith("}"):
+                    inference2 = json.loads(resp2)
+                else:
+                    repaired = repair_json(resp2)
+                    inference2 = json.loads(repaired) if isinstance(repaired, str) else repaired
+                if not isinstance(inference2, dict):
+                    logger.warning(f"jargon {content} 推断2结果格式错误")
+                    return
+            except Exception as e:
+                logger.error(f"jargon {content} 推断2解析失败: {e}")
+                return
+            logger.info(f"jargon {content} 推断2提示词: {prompt2}")
+            logger.info(f"jargon {content} 推断2结果: {response2}")
+            # logger.info(f"jargon {content} 推断2结果: {inference2}")
+            logger.info(f"jargon {content} 推断1提示词: {prompt1}")
+            logger.info(f"jargon {content} 推断1结果: {response1}")
+            # logger.info(f"jargon {content} 推断1结果: {inference1}")
+            
+            # 步骤3: 比较两个推断结果
+            prompt3 = await global_prompt_manager.format_prompt(
+                "jargon_compare_inference_prompt",
+                inference1=json.dumps(inference1, ensure_ascii=False),
+                inference2=json.dumps(inference2, ensure_ascii=False),
+            )
+            
+            logger.info(f"jargon {content} 比较提示词: {prompt3}")
+            
+            response3, _ = await self.llm.generate_response_async(prompt3, temperature=0.3)
+            if not response3:
+                logger.warning(f"jargon {content} 比较失败：无响应")
+                return
+            
+            # 解析比较结果
+            comparison = None
+            try:
+                resp3 = response3.strip()
+                if resp3.startswith("{") and resp3.endswith("}"):
+                    comparison = json.loads(resp3)
+                else:
+                    repaired = repair_json(resp3)
+                    comparison = json.loads(repaired) if isinstance(repaired, str) else repaired
+                if not isinstance(comparison, dict):
+                    logger.warning(f"jargon {content} 比较结果格式错误")
+                    return
+            except Exception as e:
+                logger.error(f"jargon {content} 比较解析失败: {e}")
+                return
+
+            # 判断是否为黑话
+            is_similar = comparison.get("is_similar", False)
+            is_jargon = not is_similar  # 如果相似，说明不是黑话；如果有差异，说明是黑话
+            
+            # 更新数据库记录
+            jargon_obj.is_jargon = is_jargon
+            if is_jargon:
+                # 是黑话，使用推断1的结果（基于上下文，更准确）
+                jargon_obj.meaning = inference1.get("meaning", "")
+                jargon_obj.translation = inference1.get("translation", "")
+            else:
+                # 不是黑话，也记录含义（使用推断2的结果，因为含义明确）
+                jargon_obj.meaning = inference2.get("meaning", "")
+                jargon_obj.translation = inference2.get("translation", "")
+            
+            # 更新最后一次判定的count值，避免重启后重复判定
+            jargon_obj.last_inference_count = jargon_obj.count or 0
+            
+            # 如果count>=100，标记为完成，不再进行推断
+            if (jargon_obj.count or 0) >= 100:
+                jargon_obj.is_complete = True
+            
+            jargon_obj.save()
+            logger.info(f"jargon {content} 推断完成: is_jargon={is_jargon}, meaning={jargon_obj.meaning}, last_inference_count={jargon_obj.last_inference_count}, is_complete={jargon_obj.is_complete}")
+            
+        except Exception as e:
+            logger.error(f"jargon推断失败: {e}")
+            import traceback
+            traceback.print_exc()
+
     def should_trigger(self) -> bool:
         # 冷却时间检查
         if time.time() - self.last_learning_time < self.min_learning_interval:
@@ -85,11 +344,15 @@ class JargonMiner:
             if not chat_stream:
                 return
 
+            # 记录本次提取的时间窗口，避免重复提取
+            extraction_start_time = self.last_learning_time
+            extraction_end_time = time.time()
+            
             # 拉取学习窗口内的消息
             messages = get_raw_msg_by_timestamp_with_chat_inclusive(
                 chat_id=self.chat_id,
-                timestamp_start=self.last_learning_time,
-                timestamp_end=time.time(),
+                timestamp_start=extraction_start_time,
+                timestamp_end=extraction_end_time,
                 limit=20,
             )
             if not messages:
@@ -135,17 +398,27 @@ class JargonMiner:
                     if not isinstance(item, dict):
                         continue
                     content = str(item.get("content", "")).strip()
-                    raw_content = str(item.get("raw_content", "")).strip()
+                    raw_content_value = item.get("raw_content", "")
+                    
+                    # 处理raw_content：可能是字符串或列表
+                    raw_content_list = []
+                    if isinstance(raw_content_value, list):
+                        raw_content_list = [str(rc).strip() for rc in raw_content_value if str(rc).strip()]
+                    elif isinstance(raw_content_value, str):
+                        raw_content_str = raw_content_value.strip()
+                        if raw_content_str:
+                            raw_content_list = [raw_content_str]
+                    
                     type_str = str(item.get("type", "")).strip().lower()
                     
                     # 验证type是否为有效值
                     if type_str not in ["p", "c", "e"]:
                         type_str = "p"  # 默认值
                     
-                    if content:
+                    if content and raw_content_list:
                         entries.append({
                             "content": content,
-                            "raw_content": raw_content,
+                            "raw_content": raw_content_list,
                             "type": type_str
                         })
             except Exception as e:
@@ -167,14 +440,20 @@ class JargonMiner:
             
             saved = 0
             updated = 0
+            merged = 0
             for entry in uniq_entries:
                 content = entry["content"]
-                raw_content = entry["raw_content"]
+                raw_content_list = entry["raw_content"]  # 已经是列表
                 type_str = entry["type"]
                 try:
+                    # 步骤1: 检查同chat_id的记录，默认纳入global项目
+                    # 查询条件：chat_id匹配 OR (is_global为True且content匹配)
                     query = (
                         Jargon.select()
-                        .where((Jargon.chat_id == self.chat_id) & (Jargon.content == content))
+                        .where(
+                            ((Jargon.chat_id == self.chat_id) | Jargon.is_global) &
+                            (Jargon.content == content)
+                        )
                     )
                     if query.exists():
                         obj = query.get()
@@ -182,30 +461,134 @@ class JargonMiner:
                             obj.count = (obj.count or 0) + 1
                         except Exception:
                             obj.count = 1
-                        # 更新raw_content和type（如果为空或需要更新）
-                        if raw_content and not obj.raw_content:
-                            obj.raw_content = raw_content
+                        
+                        # 合并raw_content列表：读取现有列表，追加新值，去重
+                        existing_raw_content = []
+                        if obj.raw_content:
+                            try:
+                                existing_raw_content = json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content
+                                if not isinstance(existing_raw_content, list):
+                                    existing_raw_content = [existing_raw_content] if existing_raw_content else []
+                            except (json.JSONDecodeError, TypeError):
+                                existing_raw_content = [obj.raw_content] if obj.raw_content else []
+                        
+                        # 合并并去重
+                        merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list))
+                        obj.raw_content = json.dumps(merged_list, ensure_ascii=False)
+                        
+                        # 更新type（如果为空）
                         if type_str and not obj.type:
                             obj.type = type_str
                         obj.save()
+                        
+                        # 检查是否需要推断（达到阈值且超过上次判定值）
+                        if _should_infer_meaning(obj):
+                            # 异步触发推断，不阻塞主流程
+                            # 重新加载对象以确保数据最新
+                            jargon_id = obj.id
+                            asyncio.create_task(self._infer_meaning_by_id(jargon_id))
+                        
                         updated += 1
                     else:
-                        Jargon.create(
-                            content=content,
-                            raw_content=raw_content,
-                            type=type_str,
-                            chat_id=self.chat_id,
-                            is_global=False,
-                            count=1
+                        # 步骤2: 同chat_id没有找到，检查所有chat_id中是否有相同content的记录
+                        # 查询所有非global的记录（global的已经在步骤1检查过了）
+                        all_content_query = (
+                            Jargon.select()
+                            .where(
+                                (Jargon.content == content) &
+                                (~Jargon.is_global)
+                            )
                         )
-                        saved += 1
+                        all_matching = list(all_content_query)
+                        
+                        # 如果找到3个或更多相同content的记录，合并它们
+                        if len(all_matching) >= 3:
+                            # 找到3个或更多已有记录，合并它们（新条目也会被包含在合并中）
+                            total_count = sum((obj.count or 0) for obj in all_matching) + 1  # +1 是因为当前新条目
+                            
+                            # 合并所有raw_content列表
+                            all_raw_content = []
+                            for obj in all_matching:
+                                if obj.raw_content:
+                                    try:
+                                        obj_raw = json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content
+                                        if not isinstance(obj_raw, list):
+                                            obj_raw = [obj_raw] if obj_raw else []
+                                        all_raw_content.extend(obj_raw)
+                                    except (json.JSONDecodeError, TypeError):
+                                        if obj.raw_content:
+                                            all_raw_content.append(obj.raw_content)
+                            
+                            # 添加当前新条目的raw_content
+                            all_raw_content.extend(raw_content_list)
+                            # 去重
+                            merged_raw_content = list(dict.fromkeys(all_raw_content))
+                            
+                            # 合并type：优先使用非空的值
+                            merged_type = type_str
+                            for obj in all_matching:
+                                if obj.type and not merged_type:
+                                    merged_type = obj.type
+                                    break
+                            
+                            # 合并其他字段：优先使用已有值
+                            merged_meaning = None
+                            merged_translation = None
+                            merged_is_jargon = None
+                            merged_last_inference_count = None
+                            merged_is_complete = False
+                            
+                            for obj in all_matching:
+                                if obj.meaning and not merged_meaning:
+                                    merged_meaning = obj.meaning
+                                if obj.translation and not merged_translation:
+                                    merged_translation = obj.translation
+                                if obj.is_jargon is not None and merged_is_jargon is None:
+                                    merged_is_jargon = obj.is_jargon
+                                if obj.last_inference_count is not None and merged_last_inference_count is None:
+                                    merged_last_inference_count = obj.last_inference_count
+                                if obj.is_complete:
+                                    merged_is_complete = True
+                            
+                            # 删除旧的记录
+                            for obj in all_matching:
+                                obj.delete_instance()
+                            
+                            # 创建新的global记录
+                            Jargon.create(
+                                content=content,
+                                raw_content=json.dumps(merged_raw_content, ensure_ascii=False),
+                                type=merged_type,
+                                chat_id="global",
+                                is_global=True,
+                                count=total_count,
+                                meaning=merged_meaning,
+                                translation=merged_translation,
+                                is_jargon=merged_is_jargon,
+                                last_inference_count=merged_last_inference_count,
+                                is_complete=merged_is_complete
+                            )
+                            merged += 1
+                            logger.info(f"合并jargon为global: content={content}, 合并了{len(all_matching)}条已有记录+1条新记录（共{len(all_matching)+1}条），总count={total_count}")
+                        else:
+                            # 找到少于3个已有记录，正常创建新记录
+                            Jargon.create(
+                                content=content,
+                                raw_content=json.dumps(raw_content_list, ensure_ascii=False),
+                                type=type_str,
+                                chat_id=self.chat_id,
+                                is_global=False,
+                                count=1
+                            )
+                            saved += 1
                 except Exception as e:
                     logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}")
                     continue
 
-            if saved or updated:
-                logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}")
-                self.last_learning_time = time.time()
+            if saved or updated or merged:
+                logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，合并为global {merged} 条，chat_id={self.chat_id}")
+                # 更新为本次提取的结束时间，确保不会重复提取相同的消息窗口
+                self.last_learning_time = extraction_end_time
         except Exception as e:
             logger.error(f"JargonMiner 运行失败: {e}")
 

src/plugin_system/base/base_tool.py

@@ -57,7 +57,7 @@ class BaseTool(ABC):
         Returns:
             dict: 工具定义字典
         """
-        if not cls.name or not cls.description or not cls.parameters:
+        if not cls.name or not cls.description or cls.parameters is None:
             raise NotImplementedError(f"工具类 {cls.__name__} 必须定义 name, description 和 parameters 属性")
 
         return {"name": cls.name, "description": cls.description, "parameters": cls.parameters}
@@ -65,7 +65,7 @@ class BaseTool(ABC):
     @classmethod
     def get_tool_info(cls) -> ToolInfo:
         """获取工具信息"""
-        if not cls.name or not cls.description or not cls.parameters:
+        if not cls.name or not cls.description or cls.parameters is None:
             raise NotImplementedError(f"工具类 {cls.__name__} 必须定义 name, description 和 parameters 属性")
 
         return ToolInfo(

src/plugins/built_in/jargon/_manifest.json

@@ -0,0 +1,36 @@
+{
+  "manifest_version": 1,
+  "name": "Jargon插件",
+  "version": "1.0.0",
+  "description": "记录和管理jargon（黑话/俚语）的解释",
+  "author": {
+    "name": "Mai",
+    "url": "https://github.com/MaiM-with-u"
+  },
+  "license": "GPL-v3.0-or-later",
+  
+  "host_application": {
+    "min_version": "0.10.4"
+  },
+  "homepage_url": "https://github.com/MaiM-with-u/maibot",
+  "repository_url": "https://github.com/MaiM-with-u/maibot",
+  "keywords": ["jargon", "slang", "built-in"],
+  "categories": ["Jargon"],
+  
+  "default_locale": "zh-CN",
+  "locales_path": "_locales",
+  
+  "plugin_info": {
+    "is_built_in": true,
+    "plugin_type": "tool_provider",
+    "components": [
+      {
+        "type": "record_jargon_explanation",
+        "name": "record_jargon_explanation", 
+        "description": "记录聊天中明确解释的jargon词义"
+      }
+    ]
+  }
+}
+
+

src/plugins/built_in/jargon/jargon_explanation.py

@@ -0,0 +1,180 @@
+from typing import Any, Dict, List, Tuple
+
+from src.common.logger import get_logger
+from src.common.database.database_model import Jargon
+from src.plugin_system import BaseTool, ToolParamType
+
+logger = get_logger("jargon_explanation")
+
+
+class RecordJargonExplanationTool(BaseTool):
+    """记录jargon解释工具
+    
+    检测聊天记录中是否有对某个词义的明确解释，如果有则记录到jargon表中
+    """
+
+    name: str = "record_explanation"
+    description: str = (
+        "当检测到有人明确解释了某个缩写，拼音缩写，中文缩写，英文缩写的含义时（例如：'xxx是yyy的意思'、'xxx指的是yyy'等)"
+        "当某人明确纠正了对某个词汇的错误解释时（例如：'xxx不是yyy的意思'、'xxx不是指的是yyy'等)"
+    )
+    parameters: List[Tuple[str, ToolParamType, str, bool, None]] = [
+        ("content", ToolParamType.STRING, "被解释的目标词汇（黑话/俚语/缩写），例如：yyds、内卷、社死等", True, None),
+        ("translation", ToolParamType.STRING, "词汇的翻译或简称，例如：永远的神、社会性死亡等", True, None),
+        ("meaning", ToolParamType.STRING, "词汇的详细含义说明", True, None),
+    ]
+    available_for_llm: bool = True
+
+    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, str]:
+        """执行jargon解释检测和记录
+
+        Args:
+            function_args: 工具参数，包含content、translation、meaning
+
+        Returns:
+            dict: 工具执行结果
+        """
+        if not self.chat_id:
+            return {"name": self.name, "content": "无法记录jargon解释：缺少chat_id"}
+
+        try:
+            # 从参数中获取信息
+            content = str(function_args.get("content", "")).strip()
+            translation = str(function_args.get("translation", "")).strip()
+            meaning = str(function_args.get("meaning", "")).strip()
+            
+            if not content:
+                return {"name": self.name, "content": "目标词汇不能为空"}
+            
+            if not translation and not meaning:
+                return {"name": self.name, "content": "翻译和含义至少需要提供一个"}
+                
+            # 检查是否已存在相同的jargon
+            query = Jargon.select().where(
+                (Jargon.chat_id == self.chat_id) & 
+                (Jargon.content == content)
+            )
+            
+            if query.exists():
+                # 已存在，更新translation和meaning（追加，用/分隔）
+                obj = query.get()
+                existing_translation = obj.translation or ""
+                existing_meaning = obj.meaning or ""
+                
+                # 追加新内容
+                if translation:
+                    if existing_translation:
+                        obj.translation = f"{existing_translation}/{translation}"
+                    else:
+                        obj.translation = translation
+                
+                if meaning:
+                    if existing_meaning:
+                        obj.meaning = f"{existing_meaning}/{meaning}"
+                    else:
+                        obj.meaning = meaning
+                
+                # 确保is_jargon为True
+                obj.is_jargon = True
+                obj.save()
+                
+                logger.info(f"更新jargon解释: {content}, translation={obj.translation}, meaning={obj.meaning}")
+                # 优先使用meaning，如果没有则使用translation
+                explanation = obj.meaning or obj.translation or ""
+                return {"name": self.name, "content": f"你了解到 {content}的含义应该是 {explanation}"}
+            else:
+                # 新建记录
+                Jargon.create(
+                    content=content,
+                    chat_id=self.chat_id,
+                    translation=translation,
+                    meaning=meaning,
+                    is_jargon=True,
+                    is_global=False,
+                    count=0,
+                )
+                
+                logger.info(f"记录新jargon解释: {content}, translation={translation}, meaning={meaning}")
+                # 优先使用meaning，如果没有则使用translation
+                explanation = meaning or translation or ""
+                return {"name": self.name, "content": f"你了解到 {content}的含义应该是 {explanation}"}
+                
+        except Exception as exc:
+            logger.error(f"记录jargon解释失败: {exc}", exc_info=True)
+            return {"name": self.name, "content": f"记录jargon解释失败: {exc}"}
+
+
+class LookupJargonMeaningTool(BaseTool):
+    """查询jargon含义工具
+    
+    输入一个可能意义不明的词或缩写，查询数据库中是否已有匹配且带有含义或翻译的记录。
+    命中则返回解释字符串（优先meaning，其次translation），未命中返回空字符串。
+    """
+
+    name: str = "lookup_jargon_meaning"
+    description: str = (
+        "查询是否存在已知的jargon解释（含meaning或translation），若存在返回解释，否则返回空字符串"
+    )
+    parameters: List[Tuple[str, ToolParamType, str, bool, None]] = [
+        ("content", ToolParamType.STRING, "待查询的目标词汇（黑话/俚语/缩写）", True, None),
+    ]
+    available_for_llm: bool = True
+
+    async def execute(self, function_args: Dict[str, Any]) -> Dict[str, str]:
+        if not self.chat_id:
+            # 和其它工具保持一致的返回结构
+            return {"name": self.name, "content": ""}
+
+        try:
+            content = str(function_args.get("content", "")).strip()
+            if not content:
+                return {"name": self.name, "content": ""}
+
+            # 优先在当前会话或global中查找该content，且需要meaning或translation非空
+            # Peewee 条件：
+            # (content == 输入) AND ((chat_id == 当前chat) OR is_global) AND ((meaning非空) OR (translation非空))
+            candidates = (
+                Jargon.select()
+                .where(
+                    (Jargon.content == content)
+                    & ((Jargon.chat_id == self.chat_id) | Jargon.is_global)
+                    & (
+                        ((Jargon.meaning.is_null(False)) & (Jargon.meaning != ""))
+                        | ((Jargon.translation.is_null(False)) & (Jargon.translation != ""))
+                    )
+                )
+                .limit(1)
+            )
+
+            if candidates.exists():
+                obj = candidates.get()
+                translation = (obj.translation or "").strip()
+                meaning = (obj.meaning or "").strip()
+                formatted = f"“{content}可能为黑话或者网络简写，翻译为：{translation}，含义为：{meaning}”"
+                return {"name": self.name, "content": formatted}
+
+            # 未命中：允许退化为全库搜索（不限chat_id），以提升命中率
+            fallback = (
+                Jargon.select()
+                .where(
+                    (Jargon.content == content)
+                    & (
+                        ((Jargon.meaning.is_null(False)) & (Jargon.meaning != ""))
+                        | ((Jargon.translation.is_null(False)) & (Jargon.translation != ""))
+                    )
+                )
+                .limit(1)
+            )
+            if fallback.exists():
+                obj = fallback.get()
+                translation = (obj.translation or "").strip()
+                meaning = (obj.meaning or "").strip()
+                formatted = f"“{content}可能为黑话或者网络简写，翻译为：{translation}，含义为：{meaning}”"
+                return {"name": self.name, "content": formatted}
+
+            # 彻底未命中
+            return {"name": self.name, "content": ""}
+        except Exception as exc:
+            logger.error(f"查询jargon解释失败: {exc}", exc_info=True)
+            return {"name": self.name, "content": ""}
+

src/plugins/built_in/jargon/plugin.py

@@ -0,0 +1,56 @@
+from typing import List, Tuple, Type
+
+# 导入新插件系统
+from src.plugin_system import BasePlugin, ComponentInfo, register_plugin
+from src.plugin_system.base.config_types import ConfigField
+
+# 导入依赖的系统组件
+from src.common.logger import get_logger
+
+from src.plugins.built_in.jargon.jargon_explanation import RecordJargonExplanationTool, LookupJargonMeaningTool
+
+logger = get_logger("jargon_plugin")
+
+
+@register_plugin
+class JargonPlugin(BasePlugin):
+    """Jargon插件
+
+    系统内置插件，提供jargon相关的功能：
+    - RecordJargonExplanation: 记录聊天中明确解释的jargon词义
+    - LookupJargonMeaning: 查询未知词是否已有解释
+
+    注意：插件基本信息优先从_manifest.json文件中读取
+    """
+
+    # 插件基本信息
+    plugin_name: str = "jargon"  # 内部标识符
+    enable_plugin: bool = True
+    dependencies: list[str] = []  # 插件依赖列表
+    python_dependencies: list[str] = []  # Python包依赖列表
+    config_file_name: str = "config.toml"
+
+    # 配置节描述
+    config_section_descriptions = {
+        "plugin": "插件启用配置",
+        "components": "核心组件启用配置",
+    }
+
+    # 配置Schema定义
+    config_schema: dict = {
+        "plugin": {
+            "enabled": ConfigField(type=bool, default=True, description="是否启用插件"),
+            "config_version": ConfigField(type=str, default="1.0.0", description="配置文件版本"),
+        },
+    }
+
+    def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]:
+        """返回插件包含的组件列表"""
+
+        # --- 根据配置注册组件 ---
+        components = []
+        components.append((RecordJargonExplanationTool.get_tool_info(), RecordJargonExplanationTool))
+        components.append((LookupJargonMeaningTool.get_tool_info(), LookupJargonMeaningTool))
+
+        return components
+