aiforge-engine 0.0.2__tar.gz → 0.0.4__tar.gz

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiforge-engine
-Version: 0.0.2
+Version: 0.0.4
 Summary: Intelligent Intent Adaptive Execution Engine - 智能意图自适应执行引擎
 Project-URL: Homepage, https://github.com/iniwap/AIForge
 Project-URL: Documentation, https://iniwap.github.io/AIForge
@@ -67,7 +67,7 @@ Description-Content-Type: text/markdown
 ---  
   
 ## 🎯 什么是 AIForge？  
-![alt text](logo.jpg)  
+![LOGO](https://raw.githubusercontent.com/iniwap/AIForge/main/logo.jpg)  
 AIForge 是一个**突破性的认知计算引擎**，它消除了自然语言与代码执行之间的壁垒。通过先进的**意图理解算法**和**自适应执行架构**，AIForge 能够：  
   
 - 🧠 **深度理解** - 多维度解析复杂指令，精准捕获用户意图  
@@ -102,7 +102,7 @@ AIForge 是一个**突破性的认知计算引擎**，它消除了自然语言
   
 ## 🚀 快速启动  
   
-### 安装  
+### 安装（推荐uv）  
 ```bash  
 pip install aiforge-engine  
 ```  

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/README.md

@@ -15,7 +15,7 @@
 ---  
   
 ## 🎯 什么是 AIForge？  
-![alt text](logo.jpg)  
+![LOGO](https://raw.githubusercontent.com/iniwap/AIForge/main/logo.jpg)  
 AIForge 是一个**突破性的认知计算引擎**，它消除了自然语言与代码执行之间的壁垒。通过先进的**意图理解算法**和**自适应执行架构**，AIForge 能够：  
   
 - 🧠 **深度理解** - 多维度解析复杂指令，精准捕获用户意图  
@@ -50,7 +50,7 @@ AIForge 是一个**突破性的认知计算引擎**，它消除了自然语言
   
 ## 🚀 快速启动  
   
-### 安装  
+### 安装（推荐uv）  
 ```bash  
 pip install aiforge-engine  
 ```  

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aiforge-engine"
-version = "0.0.2"
+version = "0.0.4"
 description = "Intelligent Intent Adaptive Execution Engine - 智能意图自适应执行引擎"
 readme = "README.md"
 license = { text = "Apache 2.0" }

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/__init__.py

@@ -61,4 +61,4 @@ __all__ = [
     "AIForgePrompt",
 ]
 
-__version__ = "0.0.2"
+__version__ = "0.0.4"

aiforge_engine-0.0.4/src/aiforge/core/managers/content_generation_manager.py

@@ -0,0 +1,359 @@
+import time
+from typing import Dict, Any, Optional
+from ...strategies.semantic_field_strategy import SemanticFieldStrategy
+
+
+class AIForgeContentGenerationManager:
+    """内容生成管理器 - 专门处理内容生成任务"""
+
+    def __init__(self, components: Dict[str, Any]):
+        self.components = components
+        self.field_processor = SemanticFieldStrategy()
+        self.parameter_mapping_service = components.get("parameter_mapping_service")
+
+        # 扩展语义字段定义，支持格式相关参数
+        if hasattr(self.field_processor, "field_semantics"):
+            self.field_processor.field_semantics.update(
+                {
+                    "format": [
+                        "format",
+                        "output_format",
+                        "格式",
+                        "输出格式",
+                        "type",
+                        "extension",
+                        "文件格式",
+                    ],
+                    "style": ["style", "样式", "风格", "theme", "template", "模板"],
+                    "language": ["language", "lang", "语言", "locale", "国际化"],
+                    "tone": ["tone", "语调", "风格", "mood", "情感"],
+                }
+            )
+
+    def can_handle_content_generation(self, standardized_instruction: Dict[str, Any]) -> bool:
+        """判断是否为内容生成任务"""
+        task_type = standardized_instruction.get("task_type", "")
+        return task_type == "content_generation"
+
+    def execute_content_generation(
+        self, standardized_instruction: Dict[str, Any], instruction: str
+    ) -> Optional[Dict[str, Any]]:
+        """执行内容生成任务"""
+        if standardized_instruction.get("execution_mode", "") == "code_generation":
+            return self._execute_search_enhanced_generation(standardized_instruction, instruction)
+        else:
+            return self._execute_direct_generation(standardized_instruction, instruction)
+
+    def _execute_search_enhanced_generation(
+        self, standardized_instruction: Dict[str, Any], instruction: str
+    ) -> Optional[Dict[str, Any]]:
+        """执行搜索增强的内容生成"""
+        search_manager = self.components.get("search_manager")
+        if not search_manager:
+            return self._execute_direct_generation(standardized_instruction, instruction)
+
+        # 为内容生成任务优化搜索参数，确保足够的结果数量
+        content_search_instruction = standardized_instruction.copy()
+        content_search_instruction.update(
+            {
+                "task_type": "data_fetch",
+                "required_parameters": {
+                    # 保留原有参数
+                    **standardized_instruction.get("required_parameters", {}),
+                    "search_query": {
+                        "value": search_manager.extract_search_query(
+                            standardized_instruction, instruction
+                        ),
+                        "type": "string",
+                        "required": True,
+                    },
+                    "max_results": {
+                        "value": 10,
+                        "type": "int",
+                        "required": False,
+                    },
+                    "min_items": {
+                        "value": 5,
+                        "type": "int",
+                        "required": True,
+                    },
+                    "min_abstract_len": {
+                        "value": 500,
+                        "type": "int",
+                        "required": False,
+                    },
+                    "max_abstract_len": {
+                        "value": 1000,
+                        "type": "int",
+                        "required": False,
+                    },
+                },
+                "expected_output": {
+                    "required_fields": ["title", "content", "url", "pub_time"],
+                    "validation_rules": {
+                        "min_items": 5,
+                        "non_empty_fields": ["title", "content", "url"],
+                        "enable_deduplication": True,
+                    },
+                },
+            }
+        )
+
+        # 使用完整的多层级搜索
+        search_result = search_manager.execute_multi_level_search(
+            content_search_instruction, instruction
+        )
+
+        if search_result and search_result.get("status") == "success":
+            return self._generate_content_with_search_result(
+                standardized_instruction, instruction, search_result
+            )
+        else:
+            return self._execute_direct_generation(standardized_instruction, instruction)
+
+    def _execute_direct_generation(
+        self, standardized_instruction: Dict[str, Any], instruction: str
+    ) -> Optional[Dict[str, Any]]:
+        """执行直接内容生成"""
+        output_format = self._extract_output_format_with_mapping(standardized_instruction)
+        style_params = self._extract_style_parameters(standardized_instruction)
+
+        enhanced_instruction = f"""
+        请根据用户要求：{instruction}，生成文章内容。
+
+        输出格式要求：{output_format}
+        样式要求：{style_params.get('style', '专业')}
+        语调：{style_params.get('tone', '客观')}
+        语言：{style_params.get('language', '中文')}
+
+        特别注意：
+        1. 严格按照{output_format}格式输出
+        2. 确保内容结构清晰，格式规范
+        3. 内容要有逻辑性和可读性
+        4. 保持{style_params.get('tone', '客观')}的语调
+        """
+
+        return self._call_llm_for_content(
+            enhanced_instruction, output_format, standardized_instruction
+        )
+
+    def _generate_content_with_search_result(
+        self,
+        standardized_instruction: Dict[str, Any],
+        instruction: str,
+        search_result: Dict[str, Any],
+    ) -> Optional[Dict[str, Any]]:
+        """基于搜索结果生成内容"""
+        search_data = search_result.get("data", [])
+        output_format = self._extract_output_format_with_mapping(standardized_instruction)
+        style_params = self._extract_style_parameters(standardized_instruction)
+
+        # 格式化搜索结果
+        if len(search_data) > 0:
+            formatted = f"关于'{instruction}'的搜索结果：\n\n"
+            for i, result in enumerate(search_data, 1):
+                formatted += f"## 结果 {i}\n"
+                formatted += f"**标题**: {result.get('title', '无标题')}\n"
+                formatted += f"**发布时间**: {result.get('pub_time', '未知时间')}\n"
+                formatted += f"**摘要**: {result.get('abstract', '无摘要')}\n"
+                formatted += f"**内容**: {result.get('content', '')}...\n"
+                formatted += "\n"
+        else:
+            formatted = "未找到相关搜索结果，请基于已有知识生成内容。"
+
+        enhanced_instruction = f"""
+        请基于以下搜索到的最新数据内容：
+        {formatted}
+
+        和用户任务要求：{instruction}，生成文章内容。
+
+        输出格式要求：{output_format}
+        样式要求：{style_params.get('style', '专业')}
+        语调：{style_params.get('tone', '客观')}
+        语言：{style_params.get('language', '中文')}
+
+        特别注意：
+        1. 文章中的日期必须采用搜索结果的日期
+        2. 严格按照{output_format}格式输出
+        3. 确保内容结构清晰，格式规范
+        4. 基于搜索结果的真实数据进行分析和创作
+        5. 保持{style_params.get('tone', '客观')}的语调
+        """
+
+        return self._call_llm_for_content(
+            enhanced_instruction, output_format, standardized_instruction, len(search_data)
+        )
+
+    def _extract_output_format_with_mapping(self, standardized_instruction: Dict[str, Any]) -> str:
+        """使用参数映射服务提取输出格式"""
+        parameters = standardized_instruction.get("required_parameters", {})
+
+        # 使用参数映射服务进行格式参数映射
+        if self.parameter_mapping_service:
+            # 创建虚拟函数来获取格式参数
+            def dummy_format_function(
+                output_format="markdown", format="markdown", type="markdown", extension="md"
+            ):
+                # 优先级：output_format > format > type > extension
+                for param in [output_format, format, type, extension]:
+                    if param and param != "markdown" and param != "md":
+                        return param
+                return "markdown"
+
+            context = {
+                "task_type": standardized_instruction.get("task_type"),
+                "action": standardized_instruction.get("action"),
+                "function_name": "extract_format",
+            }
+
+            try:
+                mapped_params = self.parameter_mapping_service.map_parameters(
+                    dummy_format_function, parameters, context
+                )
+                result = dummy_format_function(**mapped_params)
+                if result and result != "markdown":
+                    return result.lower()
+            except Exception:
+                pass
+
+        # 回退到原有逻辑
+        return self._fallback_format_extraction(standardized_instruction)
+
+    def _extract_style_parameters(self, standardized_instruction: Dict[str, Any]) -> Dict[str, str]:
+        """使用参数映射服务提取样式参数"""
+        parameters = standardized_instruction.get("required_parameters", {})
+        style_params = {"style": "专业", "tone": "客观", "language": "中文"}
+
+        if self.parameter_mapping_service:
+            # 创建虚拟函数来获取样式参数
+            def dummy_style_function(
+                style="专业", tone="客观", language="中文", theme="专业", mood="客观", lang="中文"
+            ):
+                return {
+                    "style": style or theme or "专业",
+                    "tone": tone or mood or "客观",
+                    "language": language or lang or "中文",
+                }
+
+            context = {
+                "task_type": standardized_instruction.get("task_type"),
+                "action": standardized_instruction.get("action"),
+                "function_name": "extract_style",
+            }
+
+            try:
+                mapped_params = self.parameter_mapping_service.map_parameters(
+                    dummy_style_function, parameters, context
+                )
+                result = dummy_style_function(**mapped_params)
+                style_params.update(result)
+            except Exception:
+                pass
+
+        return style_params
+
+    def _fallback_format_extraction(self, standardized_instruction: Dict[str, Any]) -> str:
+        """回退的格式提取逻辑"""
+        # 直接检查参数
+        parameters = standardized_instruction.get("required_parameters", {})
+        format_params = ["output_format", "format", "type", "extension"]
+
+        for param_name in format_params:
+            if param_name in parameters:
+                param_info = parameters[param_name]
+                if isinstance(param_info, dict) and "value" in param_info:
+                    return param_info["value"].lower()
+                elif isinstance(param_info, str):
+                    return param_info.lower()
+
+        # 检查指令中是否包含格式要求
+        instruction_lower = standardized_instruction.get("target", "").lower()
+        format_keywords = {
+            "markdown": ["markdown", "md", "标记语言"],
+            "html": ["html", "网页", "web"],
+            "json": ["json", "数据格式"],
+            "xml": ["xml"],
+            "pdf": ["pdf"],
+            "docx": ["word", "docx", "文档"],
+            "txt": ["txt", "文本", "纯文本"],
+        }
+
+        for format_type, keywords in format_keywords.items():
+            if any(keyword in instruction_lower for keyword in keywords):
+                return format_type
+
+        # 默认返回markdown
+        return "markdown"
+
+    def _call_llm_for_content(
+        self,
+        enhanced_instruction: str,
+        output_format: str,
+        standardized_instruction: Dict[str, Any],
+        search_results_count: int = 0,
+    ) -> Dict[str, Any]:
+        """调用LLM生成内容"""
+        llm_manager = self.components.get("llm_manager")
+        if not llm_manager:
+            return {
+                "data": {"content": "LLM管理器不可用"},
+                "status": "error",
+                "summary": "内容生成失败：LLM管理器不可用",
+            }
+
+        client = llm_manager.get_client()
+        if not client:
+            return {
+                "data": {"content": "LLM客户端不可用"},
+                "status": "error",
+                "summary": "内容生成失败：LLM客户端不可用",
+            }
+        try:
+            content = client.generate_code(enhanced_instruction, None, use_history=False)
+
+            return {
+                "data": {
+                    "content": content,
+                    "format": output_format,
+                    "content_type": self._get_content_type(output_format),
+                },
+                "status": "success",
+                "summary": f"成功生成{output_format}格式内容"
+                + (f"（基于{search_results_count}条搜索结果）" if search_results_count > 0 else ""),
+                "metadata": {
+                    "timestamp": time.time(),
+                    "task_type": "content_generation",
+                    "execution_type": (
+                        "search_enhanced_content" if search_results_count > 0 else "direct_content"
+                    ),
+                    "output_format": output_format,
+                    "search_results_count": search_results_count,
+                },
+            }
+        except Exception as e:
+            return {
+                "data": {"content": f"内容生成出错：{str(e)}"},
+                "status": "error",
+                "summary": f"内容生成失败：{str(e)}",
+            }
+
+    def _get_content_type(self, output_format: str) -> str:
+        """根据格式返回内容类型"""
+        format_mapping = {
+            "markdown": "text/markdown",
+            "html": "text/html",
+            "json": "application/json",
+            "xml": "application/xml",
+            "pdf": "application/pdf",
+            "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "txt": "text/plain",
+        }
+        return format_mapping.get(output_format, "text/plain")
+
+    def get_supported_formats(self) -> list:
+        """获取支持的输出格式列表"""
+        return ["markdown", "html", "json", "xml", "pdf", "docx", "txt"]
+
+    def validate_format(self, format_name: str) -> bool:
+        """验证格式是否支持"""
+        return format_name.lower() in self.get_supported_formats()

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/core/managers/execution_manager.py

@@ -30,25 +30,14 @@ class AIForgeExecutionManager:
 
     def _run_with_standardized_instruction(self, instruction: str) -> Optional[Dict[str, Any]]:
         """基于标准化指令的统一执行流程"""
-        instruction_analyzer = self.components.get("instruction_analyzer")
-
-        if not instruction_analyzer:
+        if not self.components.get("instruction_analyzer"):
             result, _, _ = self.generate_and_execute_with_code(instruction, None, None)
             return result
 
         # 使用统一的指令分析入口
         standardized_instruction = self._get_final_standardized_instruction(instruction)
 
-        # 委托给搜索管理器处理搜索任务
-        search_manager = self.components.get("search_manager")
-        if search_manager and search_manager.is_search_task(standardized_instruction):
-            result = search_manager.execute_multi_level_search(
-                standardized_instruction, instruction
-            )
-            if result["status"] != "error" and len(result["data"]) != 0:
-                return result
-
-        # 非搜索的执行逻辑...
+        task_type = standardized_instruction.get("task_type", "")
         execution_mode = standardized_instruction.get("execution_mode", "code_generation")
         confidence = standardized_instruction.get("confidence", 0)
 
@@ -63,6 +52,29 @@ class AIForgeExecutionManager:
         elif execution_mode == "direct_ai_response" and confidence >= 0.6:
             return self._handle_direct_response(standardized_instruction, instruction)
 
+        # 内容生成任务委托给专门的管理器
+        if task_type == "content_generation":
+            content_generation_manager = self.components.get("content_generation_manager")
+            if (
+                content_generation_manager
+                and content_generation_manager.can_handle_content_generation(
+                    standardized_instruction
+                )
+            ):
+                return content_generation_manager.execute_content_generation(
+                    standardized_instruction, instruction
+                )
+
+        # 数据获取任务委托给搜索管理器
+        if task_type == "data_fetch":
+            search_manager = self.components.get("search_manager")
+            if search_manager and search_manager.is_search_task(standardized_instruction):
+                result = search_manager.execute_multi_level_search(
+                    standardized_instruction, instruction
+                )
+                if result["status"] != "error" and len(result["data"]) != 0:
+                    return result
+
         # 其他类型按原有逻辑处理
         code_cache = self.components.get("code_cache")
         if code_cache:

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/core/managers/search_manager.py

@@ -15,17 +15,11 @@ class AIForgeSearchManager:
 
     def is_search_task(self, standardized_instruction: Dict[str, Any]) -> bool:
         """判断是否为搜索类任务"""
-        task_type = standardized_instruction.get("task_type", "")
         action = standardized_instruction.get("action", "")
 
-        execution_mode = standardized_instruction.get("execution_mode", "")
-        if execution_mode == "direct_ai_response":
-            return False
-
         # 检查任务类型和动作
         search_indicators = [
-            task_type == "data_fetch",
-            action in ["search", "fetch", "get"],
+            any(keyword in action.lower() for keyword in ["search", "fetch", "get"]),
             "search" in standardized_instruction.get("target", "").lower(),
         ]
 
@@ -46,7 +40,6 @@ class AIForgeSearchManager:
             search_params = self.parameter_mapping_service.extract_search_parameters(
                 standardized_instruction, original_instruction
             )
-
             if not search_params["search_query"]:
                 return None
 
@@ -229,13 +222,24 @@ class AIForgeSearchManager:
         except Exception:
             return None, False
 
-    def _extract_search_query(
-        self, standardized_instruction: Dict[str, Any], original_instruction: str
+    def extract_search_query(
+        self, standardized_instruction: Dict[str, Any], instruction: str
     ) -> str:
         """提取搜索查询"""
+        if self.parameter_mapping_service:
+            # 使用现有的搜索参数提取服务
+            try:
+                search_params = self.parameter_mapping_service.extract_search_parameters(
+                    standardized_instruction, instruction
+                )
+                return search_params.get("search_query", instruction)
+            except Exception:
+                pass
+
+        # 回退逻辑：直接从参数中提取
         parameters = standardized_instruction.get("required_parameters", {})
 
-        # 尝试从参数中提取
+        # 尝试从参数中提取搜索查询
         for param_name in ["search_query", "query", "keyword"]:
             if param_name in parameters:
                 param_info = parameters[param_name]
@@ -249,8 +253,8 @@ class AIForgeSearchManager:
         if target:
             return target
 
-        # 使用原始指令
-        return original_instruction
+        # 使用原始指令作为最后的回退
+        return instruction
 
     def _convert_search_result_to_aiforge_format(
         self,
@@ -266,7 +270,6 @@ class AIForgeSearchManager:
         success = search_result.get("success", False)
         error = search_result.get("error")
 
-        # 应用字段映射
         expected_output = standardized_instruction.get("expected_output")
         if expected_output and expected_output.get("required_fields"):
             results = self.processor_manager.process_field(
@@ -382,7 +385,7 @@ class AIForgeSearchManager:
             return freeform_result
 
         ProgressIndicator.show_search_process("系统默认")
-        # 所有层级都失败
+        # 所有层级都失败，系统搜索成功率较低
         return {
             "data": [],
             "status": "error",

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/core/orchestrator.py

@@ -19,6 +19,7 @@ from ..templates.template_manager import TemplateManager
 from .managers.config_manager import AIForgeConfigManager
 from ..strategies.parameter_mapping_service import ParameterMappingService
 from ..execution.engine import AIForgeExecutionEngine
+from .managers.content_generation_manager import AIForgeContentGenerationManager
 
 
 class AIForgeOrchestrator:
@@ -55,6 +56,7 @@ class AIForgeOrchestrator:
         self._init_execution_manager()
         self._init_template_manager()
         self._init_search_manager()
+        self._init_content_generation_manager()
 
         self._initialized = True
 
@@ -133,6 +135,12 @@ class AIForgeOrchestrator:
         execution_engine = AIForgeExecutionEngine(self.components)
         self.components["execution_engine"] = execution_engine
 
+    def _init_content_generation_manager(self):
+        """初始化内容生成管理器"""
+        self.components["content_generation_manager"] = AIForgeContentGenerationManager(
+            self.components
+        )
+
     def _init_adapters(self):
         """初始化适配器"""
         self.components["ui_adapter"] = None  # 延迟初始化

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/core/prompt.py

@@ -300,13 +300,13 @@ __result__ = execute_task({param_analysis['call_args']})
     def get_base_prompt_sections() -> Dict[str, str]:
         """构建基础提示词各个部分"""
         return {
-            "role": "你是 AIForge 智能任务分析器，负责理解用户指令并分析完成任务所需的必要信息。",
+            "role": "你是 AIForge 智能任务分析器，负责理解用户指令并分析完成任务所需的必要信息以及预期结果",
             "execution_mode": """
     - 直接响应：AI知识可直接完成，无需最新数据，包括对话延续和情感支持
     - 代码生成：需要外部数据源、实时信息或系统交互
     """,
             "analysis_steps": """
-    - 识别任务类型和执行模式
+    - 识别执行模式和任务类型
     - 提取关键参数和数量要求，设置合适的 min_items
     - 定义必需字段和验证规则
     - "获取/查找/搜索"某类信息的非任务型指令，仅提取一个required_parameters参数search_query=原始指令

{aiforge_engine-0.0.2 → aiforge_engine-0.0.4}/src/aiforge/strategies/parameter_mapping_service.py

@@ -20,6 +20,15 @@ class ParameterMappingService:
 
     def _extract_with_strategy(self, param_name: str, available_params: Dict[str, Any]) -> Any:
         """使用策略提取参数值"""
+
+        # 1. 首先尝试精确匹配
+        if param_name in available_params:
+            param_value = available_params[param_name]
+            if isinstance(param_value, dict) and "value" in param_value:
+                return param_value["value"]
+            return param_value
+
+        # 2. 然后使用策略匹配
         for strategy in self.strategies:
             if strategy.can_handle(param_name):
                 result = strategy.map_parameter(param_name, available_params)
@@ -136,7 +145,7 @@ class ParameterMappingService:
             "timeout": 30,
             "limit": 10,
             "min_abstract_len": 300,
-            "max_abstract_len": 500,
+            "max_abstract_len": 1000,
             "page_size": 20,
             "retry_count": 3,
             "query": "",
@@ -168,7 +177,6 @@ class ParameterMappingService:
         """专门用于搜索参数提取的方法"""
         parameters = standardized_instruction.get("required_parameters", {})
         expected_output = standardized_instruction.get("expected_output", {})
-
         # 使用现有的映射策略
         search_query = (
             self._extract_with_strategy("search_query", parameters) or original_instruction
@@ -209,7 +217,7 @@ class ParameterMappingService:
             "max_results": max_results,
             "min_items": min_items,
             "min_abstract_len": self._extract_with_strategy("min_abstract_len", parameters) or 300,
-            "max_abstract_len": self._extract_with_strategy("max_abstract_len", parameters) or 500,
+            "max_abstract_len": self._extract_with_strategy("max_abstract_len", parameters) or 1000,
         }
 
 
@@ -265,6 +273,15 @@ class SearchParameterMappingStrategy(ParameterMappingStrategy):
             # max_results 只接受明确表示"最大"语义的参数，不包括 quantity
             "max_results": ["max_results", "max_limit", "max_count", "max_size"],
             "min_items": ["min_items", "min_count", "quantity"],
+            "min_abstract_len": [
+                "min_abstract_len",
+                "min_content_len",
+                "min_article_len",
+                "abstract_len",
+                "content_len",
+                "article_len",
+            ],
+            "max_abstract_len": ["max_abstract_len", "max_content_len", "max_article_len"],
         }
 
         candidates = mappings.get(param_name, [])