diff --git a/backend/agents/create_agent_info.py b/backend/agents/create_agent_info.py
index bc4031e0a..513a5a566 100644
--- a/backend/agents/create_agent_info.py
+++ b/backend/agents/create_agent_info.py
@@ -14,6 +14,7 @@
     ElasticSearchService,
     get_vector_db_core,
     get_embedding_model,
+    get_rerank_model,
 )
 from services.remote_mcp_service import get_remote_mcp_server_list
 from services.memory_config_service import build_memory_context
@@ -296,8 +297,6 @@ async def create_agent_config(
     }
     system_prompt = Template(prompt_template["system_prompt"], undefined=StrictUndefined).render(render_kwargs)
 
-    _print_prompt_with_token_count(system_prompt, agent_id, "BEFORE_INJECTION")
-
     if agent_info.get("model_id") is not None:
         model_info = get_model_by_model_id(agent_info.get("model_id"))
         model_name = model_info["display_name"] if model_info is not None else "main_model"
@@ -350,11 +349,32 @@ async def create_tool_config_list(agent_id, tenant_id, user_id, version_no: int
                     tool_config.metadata = langchain_tool
                     break
 
-        # special logic for knowledge base search tool
+        # special logic for search tools that may use reranking models
         if tool_config.class_name == "KnowledgeBaseSearchTool":
-           tool_config.metadata = {
+            rerank = param_dict.get("rerank", False)
+            rerank_model_name = param_dict.get("rerank_model_name", "")
+            rerank_model = None
+            if rerank and rerank_model_name:
+                rerank_model = get_rerank_model(
+                    tenant_id=tenant_id, model_name=rerank_model_name
+                )
+
+            tool_config.metadata = {
                 "vdb_core": get_vector_db_core(),
                 "embedding_model": get_embedding_model(tenant_id=tenant_id),
+                "rerank_model": rerank_model,
+            }
+        elif tool_config.class_name in ["DifySearchTool", "DataMateSearchTool"]:
+            rerank = param_dict.get("rerank", False)
+            rerank_model_name = param_dict.get("rerank_model_name", "")
+            rerank_model = None
+            if rerank and rerank_model_name:
+                rerank_model = get_rerank_model(
+                    tenant_id=tenant_id, model_name=rerank_model_name
+                )
+
+            tool_config.metadata = {
+                "rerank_model": rerank_model,
             }
         elif tool_config.class_name == "AnalyzeTextFileTool":
             tool_config.metadata = {
@@ -430,25 +450,9 @@ async def prepare_prompt_templates(
     prompt_templates = get_agent_prompt_template(is_manager, language)
     prompt_templates["system_prompt"] = system_prompt
 
-    # Print final prompt with all injections
-    _print_prompt_with_token_count(prompt_templates["system_prompt"], agent_id, "FINAL_PROMPT")
-
     return prompt_templates
 
 
-def _print_prompt_with_token_count(prompt: str, agent_id: int = None, stage: str = "PROMPT"):
-    """Print prompt content and estimate token count using tiktoken."""
-    try:
-        import tiktoken
-        encoding = tiktoken.get_encoding("cl100k_base")
-        token_count = len(encoding.encode(prompt))
-        logger.info(f"[Skill Debug][{stage}] Agent {agent_id} token count: {token_count}")
-        logger.info(f"[Skill Debug][{stage}] Agent {agent_id} prompt:\n{prompt}")
-    except Exception as e:
-        logger.warning(f"[Skill Debug][{stage}] Failed to count tokens: {e}")
-        logger.info(f"[Skill Debug][{stage}] Agent {agent_id} prompt:\n{prompt}")
-
-
 async def join_minio_file_description_to_query(minio_files, query):
     final_query = query
     if minio_files and isinstance(minio_files, list):
diff --git a/backend/agents/skill_creation_agent.py b/backend/agents/skill_creation_agent.py
new file mode 100644
index 000000000..3dc0cfa80
--- /dev/null
+++ b/backend/agents/skill_creation_agent.py
@@ -0,0 +1,122 @@
+"""Skill creation agent module for interactive skill generation."""
+
+import logging
+import threading
+from typing import List
+
+from nexent.core.agents.agent_model import AgentConfig, AgentRunInfo, ModelConfig, ToolConfig
+from nexent.core.agents.run_agent import agent_run_thread
+from nexent.core.utils.observer import MessageObserver
+
+logger = logging.getLogger("skill_creation_agent")
+
+
+def create_skill_creation_agent_config(
+    system_prompt: str,
+    model_config_list: List[ModelConfig],
+    local_skills_dir: str = ""
+) -> AgentConfig:
+    """
+    Create agent config for skill creation with builtin tools.
+
+    Args:
+        system_prompt: Custom system prompt to replace smolagent defaults
+        model_config_list: List of model configurations
+
+    Returns:
+        AgentConfig configured for skill creation
+    """
+    if not model_config_list:
+        raise ValueError("model_config_list cannot be empty")
+
+    first_model = model_config_list[0]
+
+    prompt_templates = {
+        "system_prompt": system_prompt,
+        "managed_agent": {
+            "task": "{task}",
+            "report": "## {name} Report\n\n{final_answer}"
+        },
+        "planning": {
+            "initial_plan": "",
+            "update_plan_pre_messages": "",
+            "update_plan_post_messages": ""
+        },
+        "final_answer": {
+            "pre_messages": "",
+            "post_messages": ""
+        }
+    }
+
+    return AgentConfig(
+        name="__skill_creator__",
+        description="Internal skill creator agent",
+        prompt_templates=prompt_templates,
+        tools=[],
+        max_steps=5,
+        model_name=first_model.cite_name
+    )
+
+
+def run_skill_creation_agent(
+    query: str,
+    agent_config: AgentConfig,
+    model_config_list: List[ModelConfig],
+    observer: MessageObserver,
+    stop_event: threading.Event,
+) -> None:
+    """
+    Run the skill creator agent synchronously.
+
+    Args:
+        query: User query for the agent
+        agent_config: Pre-configured agent config
+        model_config_list: List of model configurations
+        observer: Message observer for capturing agent output
+        stop_event: Threading event for cancellation
+    """
+    agent_run_info = AgentRunInfo(
+        query=query,
+        model_config_list=model_config_list,
+        observer=observer,
+        agent_config=agent_config,
+        stop_event=stop_event
+    )
+
+    agent_run_thread(agent_run_info)
+
+
+def create_simple_skill_from_request(
+    system_prompt: str,
+    user_prompt: str,
+    model_config_list: List[ModelConfig],
+    observer: MessageObserver,
+    stop_event: threading.Event,
+    local_skills_dir: str = ""
+) -> None:
+    """
+    Run skill creation agent to create a skill interactively.
+
+    The agent will write the skill content to tmp.md in local_skills_dir.
+    Frontend should read tmp.md after agent completes to get the skill content.
+
+    Args:
+        system_prompt: System prompt with skill creation instructions
+        user_prompt: User's skill description request
+        model_config_list: List of model configurations
+        observer: Message observer for capturing agent output
+        stop_event: Threading event for cancellation
+        local_skills_dir: Path to local skills directory for file operations
+    """
+    agent_config = create_skill_creation_agent_config(
+        system_prompt=system_prompt,
+        model_config_list=model_config_list,
+        local_skills_dir=local_skills_dir
+    )
+
+    thread_agent = threading.Thread(
+        target=run_skill_creation_agent,
+        args=(user_prompt, agent_config, model_config_list, observer, stop_event)
+    )
+    thread_agent.start()
+    thread_agent.join()
diff --git a/backend/apps/runtime_app.py b/backend/apps/runtime_app.py
index 7420a14a2..ba856b3ce 100644
--- a/backend/apps/runtime_app.py
+++ b/backend/apps/runtime_app.py
@@ -6,6 +6,7 @@
 from apps.conversation_management_app import router as conversation_management_router
 from apps.memory_config_app import router as memory_config_router
 from apps.file_management_app import file_management_runtime_router as file_management_router
+from apps.skill_app import skill_creator_router
 from middleware.exception_handler import ExceptionHandlerMiddleware
 
 # Create logger instance
@@ -22,3 +23,4 @@
 app.include_router(memory_config_router)
 app.include_router(file_management_router)
 app.include_router(voice_router)
+app.include_router(skill_creator_router)
diff --git a/backend/apps/skill_app.py b/backend/apps/skill_app.py
index 8bf19e8b7..dd1f1d2d3 100644
--- a/backend/apps/skill_app.py
+++ b/backend/apps/skill_app.py
@@ -1,22 +1,28 @@
 """Skill management HTTP endpoints."""
 
+import asyncio
 import logging
 import os
-import re
+import threading
 from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException, Query, UploadFile, File, Form, Header
-from starlette.responses import JSONResponse
+from starlette.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
 
 from consts.exceptions import SkillException, UnauthorizedError
 from services.skill_service import SkillService
 from consts.model import SkillInstanceInfoRequest
-from utils.auth_utils import get_current_user_id
+from utils.auth_utils import get_current_user_id, get_current_user_info
+from utils.prompt_template_utils import get_skill_creation_simple_prompt_template
+from nexent.core.agents.agent_model import ModelConfig
+from agents.skill_creation_agent import create_simple_skill_from_request
+from nexent.core.utils.observer import MessageObserver
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/skills", tags=["skills"])
+skill_creator_router = APIRouter(prefix="/skills", tags=["simple-skills"])
 
 
 class SkillCreateRequest(BaseModel):
@@ -453,88 +459,143 @@ async def delete_skill(
         raise HTTPException(status_code=500, detail="Internal server error")
 
 
-@router.delete("/{skill_name}/files/{file_path:path}")
-async def delete_skill_file(
-    skill_name: str,
-    file_path: str,
-    authorization: Optional[str] = Header(None)
-) -> JSONResponse:
-    """Delete a specific file within a skill directory.
+class SkillCreateSimpleRequest(BaseModel):
+    """Request model for interactive skill creation."""
+    user_request: str
 
-    Args:
-        skill_name: Name of the skill
-        file_path: Relative path to the file within the skill directory
-    """
-    try:
-        _, _ = get_current_user_id(authorization)
-        service = SkillService()
 
-        # Validate skill_name so it cannot be used for path traversal
-        if not skill_name:
-            raise HTTPException(status_code=400, detail="Invalid skill name")
-        if os.sep in skill_name or "/" in skill_name or ".." in skill_name:
-            raise HTTPException(status_code=400, detail="Invalid skill name")
-
-        # Read config to get temp_filename for validation
-        config_content = service.get_skill_file_content(skill_name, "config.yaml")
-        if config_content is None:
-            raise HTTPException(status_code=404, detail="Config file not found")
-
-        # Parse config to get temp_filename
-        import yaml
-        config = yaml.safe_load(config_content)
-        temp_filename = config.get("temp_filename", "")
-
-        # Get the base directory for the skill
-        local_dir = os.path.join(service.skill_manager.local_skills_dir, skill_name)
-
-        # Check for path traversal patterns in the raw file_path BEFORE any normalization
-        # This catches attempts like ../../etc/passwd or /etc/passwd
-        normalized_for_check = os.path.normpath(file_path)
-        if ".." in file_path or file_path.startswith("/") or (os.sep in file_path and file_path.startswith(os.sep)):
-            # Additional check: ensure the normalized path doesn't escape local_dir
-            abs_local_dir = os.path.abspath(local_dir)
-            abs_full_path = os.path.abspath(os.path.join(local_dir, normalized_for_check))
-            try:
-                common = os.path.commonpath([abs_local_dir, abs_full_path])
-                if common != abs_local_dir:
-                    raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-            except ValueError:
-                raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-
-        # Normalize the requested file path - use basename to strip directory components
-        safe_file_path = os.path.basename(os.path.normpath(file_path))
-
-        # Build full path and validate it stays within local_dir
-        full_path = os.path.normpath(os.path.join(local_dir, safe_file_path))
-        abs_local_dir = os.path.abspath(local_dir)
-        abs_full_path = os.path.abspath(full_path)
-
-        # Check for path traversal: abs_full_path should be within abs_local_dir
-        try:
-            common = os.path.commonpath([abs_local_dir, abs_full_path])
-            if common != abs_local_dir:
-                raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
-        except ValueError:
-            # Different drives on Windows
-            raise HTTPException(status_code=400, detail="Invalid file path: path traversal detected")
+def _build_model_config_from_tenant(tenant_id: str) -> ModelConfig:
+    """Build ModelConfig from tenant's quick-config LLM model."""
+    from utils.config_utils import tenant_config_manager, get_model_name_from_config
+    from consts.const import MODEL_CONFIG_MAPPING
 
-        # Validate the filename matches temp_filename
-        if not temp_filename or safe_file_path != temp_filename:
-            raise HTTPException(status_code=400, detail="Can only delete temp_filename files")
+    quick_config = tenant_config_manager.get_model_config(
+        key=MODEL_CONFIG_MAPPING["llm"],
+        tenant_id=tenant_id
+    )
+    if not quick_config:
+        raise ValueError("No LLM model configured for tenant")
 
-        # Check if file exists
-        if not os.path.exists(full_path):
-            raise HTTPException(status_code=404, detail=f"File not found: {safe_file_path}")
+    return ModelConfig(
+        cite_name=quick_config.get("display_name", "default"),
+        api_key=quick_config.get("api_key", ""),
+        model_name=get_model_name_from_config(quick_config),
+        url=quick_config.get("base_url", ""),
+        temperature=0.1,
+        top_p=0.95,
+        ssl_verify=True,
+        model_factory=quick_config.get("model_factory")
+    )
 
-        os.remove(full_path)
-        logger.info(f"Deleted skill file: {full_path}")
 
-        return JSONResponse(content={"message": f"File {safe_file_path} deleted successfully"})
-    except UnauthorizedError as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting skill file {skill_name}/{file_path}: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+@skill_creator_router.post("/create-simple")
+async def create_simple_skill(
+    request: SkillCreateSimpleRequest,
+    authorization: Optional[str] = Header(None)
+):
+    """Create a simple skill interactively via LLM agent.
+
+    Loads the skill_creation_simple prompt template, runs an internal agent
+    with WriteSkillFileTool and ReadSkillMdTool, extracts the <SKILL> block
+    from the final answer, and streams step progress and token content via SSE.
+
+    Yields SSE events:
+        - step_count: Current agent step number
+        - skill_content: Token-level content (thinking, code, deep_thinking, tool output)
+        - final_answer: Complete skill content
+        - done: Stream completion signal
+    """
+    # Message types to stream as skill_content (token-level output)
+    STREAMABLE_CONTENT_TYPES = frozenset([
+        "model_output_thinking",
+        "model_output_code",
+        "model_output_deep_thinking",
+        "tool",
+        "execution_logs",
+    ])
+
+    async def generate():
+        import json
+        try:
+            _, tenant_id, language = get_current_user_info(authorization)
+
+            template = get_skill_creation_simple_prompt_template(language)
+
+            model_config = _build_model_config_from_tenant(tenant_id)
+            observer = MessageObserver(lang=language)
+            stop_event = threading.Event()
+
+            # Get local_skills_dir from SkillManager
+            skill_service = SkillService()
+            local_skills_dir = skill_service.skill_manager.local_skills_dir or ""
+
+            # Start skill creation in background thread
+            def run_task():
+                create_simple_skill_from_request(
+                    system_prompt=template.get("system_prompt", ""),
+                    user_prompt=request.user_request,
+                    model_config_list=[model_config],
+                    observer=observer,
+                    stop_event=stop_event,
+                    local_skills_dir=local_skills_dir
+                )
+
+            thread = threading.Thread(target=run_task)
+            thread.start()
+
+            # Poll observer for step_count and token content messages
+            while thread.is_alive():
+                cached = observer.get_cached_message()
+                for msg in cached:
+                    if isinstance(msg, str):
+                        try:
+                            data = json.loads(msg)
+                            msg_type = data.get("type", "")
+                            content = data.get("content", "")
+
+                            # Stream step progress
+                            if msg_type == "step_count":
+                                yield f"data: {json.dumps({'type': 'step_count', 'content': content}, ensure_ascii=False)}\n\n"
+                            # Stream token content (thinking, code, deep_thinking, tool output)
+                            elif msg_type in STREAMABLE_CONTENT_TYPES:
+                                yield f"data: {json.dumps({'type': 'skill_content', 'content': content}, ensure_ascii=False)}\n\n"
+                            # Stream final_answer content separately
+                            elif msg_type == "final_answer":
+                                yield f"data: {json.dumps({'type': 'final_answer', 'content': content}, ensure_ascii=False)}\n\n"
+                        except (json.JSONDecodeError, Exception):
+                            pass
+                await asyncio.sleep(0.1)
+
+            thread.join()
+
+            # Stream any remaining cached messages after thread completes
+            remaining = observer.get_cached_message()
+            for msg in remaining:
+                if isinstance(msg, str):
+                    try:
+                        data = json.loads(msg)
+                        msg_type = data.get("type", "")
+                        content = data.get("content", "")
+
+                        if msg_type == "step_count":
+                            yield f"data: {json.dumps({'type': 'step_count', 'content': content}, ensure_ascii=False)}\n\n"
+                        elif msg_type in STREAMABLE_CONTENT_TYPES:
+                            yield f"data: {json.dumps({'type': 'skill_content', 'content': content}, ensure_ascii=False)}\n\n"
+                        elif msg_type == "final_answer":
+                            yield f"data: {json.dumps({'type': 'final_answer', 'content': content}, ensure_ascii=False)}\n\n"
+                    except (json.JSONDecodeError, Exception):
+                        pass
+
+            # Stream final answer content from observer
+            final_result = observer.get_final_answer()
+            if final_result:
+                yield f"data: {json.dumps({'type': 'final_answer', 'content': final_result}, ensure_ascii=False)}\n\n"
+
+            # Send done signal
+            yield f"data: {json.dumps({'type': 'done'}, ensure_ascii=False)}\n\n"
+
+        except Exception as e:
+            logger.error(f"Error in create_simple_skill stream: {e}")
+            yield f"data: {json.dumps({'type': 'error', 'message': str(e)}, ensure_ascii=False)}\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")
diff --git a/backend/consts/const.py b/backend/consts/const.py
index 5bfd012ff..82ead68cf 100644
--- a/backend/consts/const.py
+++ b/backend/consts/const.py
@@ -326,7 +326,7 @@ class VectorDatabaseType(str, Enum):
 MODEL_ENGINE_ENABLED = os.getenv("MODEL_ENGINE_ENABLED")
 
 # APP Version
-APP_VERSION = "v1.8.1"
+APP_VERSION = "v2.0.1"
 
 # Container Platform Configuration
 IS_DEPLOYED_BY_KUBERNETES = os.getenv("IS_DEPLOYED_BY_KUBERNETES", "false").lower() == "true"
diff --git a/backend/prompts/skill_creation_simple_zh.yaml b/backend/prompts/skill_creation_simple_zh.yaml
new file mode 100644
index 000000000..e089c2999
--- /dev/null
+++ b/backend/prompts/skill_creation_simple_zh.yaml
@@ -0,0 +1,71 @@
+system_prompt: |-
+  你是一个专业的技能创建助手，用于帮助用户创建简单的技能 Markdown 说明文件，内容包括：技能名称、技能描述、技能标签、技能提示词等。
+
+  ## 工作流程
+
+  根据用户请求，直接生成技能内容并输出。**不要分步骤执行**，直接整合所有内容返回。
+
+  ## 输出格式
+
+  **重要**：所有需要写入 SKILL.md 的内容必须用 `<SKILL>` 和 `</SKILL>` XML 分隔符包裹。
+
+  ### 格式示例
+
+  ```
+  <SKILL>
+  ---
+  name: your-skill-name
+  description: 简短的第三人称描述，说明此 skill 的功能及何时应使用。包含触发词。
+  tags:
+    - tag1
+    - tag2
+  ---
+
+  # 该 Skill 的名称
+
+  ## 使用说明
+
+  Agent 的分步指导。要简洁——假设 Agent 已具备相关知识。
+
+  ## 示例（可选）
+
+  具体的使用示例。
+  </SKILL>
+
+  [这里是你对用户的友好说明，如技能已创建、功能亮点等]
+  ```
+
+  ## 编写描述（关键）
+
+  `description` 字段会被注入到 Agent 的系统提示词中用于 skill 发现。
+
+  - **使用第三人称书写**："处理 Excel 文件并生成报告"（而非"我可以帮助你..."）。
+  - **包含触发词**：特定文件类型、命令或激活此 skill 的场景。
+  - **要具体**：覆盖 WHAT 和 WHEN。
+
+  ## 禁止行为清单
+
+  - **不要**使用 "Thought:"、"Thinking:" 或任何英文思考标签 — Agent 必须使用中文格式。
+  - **不要**调用额外工具写入或读取技能文件，直接生成技能内容。
+  - **不要**在 XML 分隔符外包含 SKILL.md 的完整内容。
+  - **不要**创建多个文件、scripts/、reference.md 或 examples.md。仅限单个文件。
+  - **不要**在路径中使用 Windows 风格的反斜杠。
+
+user_prompt: |-
+  请帮我创建一个技能，需求如下：
+
+  {{user_request}}
+
+  技能内容应该包括：
+  - name: 技能名称（使用英文或拼音，字母小写，单词用连字符分隔）
+  - description: 简短的中文描述，说明此技能的功能及何时应使用，包含触发词
+  - tags: 1-3 个分类标签
+  - 主要内容：包含 ## 使用说明 和可选的 ## 示例 部分
+
+  **重要要求**：请严格按以下两个步骤进行：
+
+  **步骤 1**：生成 SKILL.md 内容并保存到文件
+
+  **步骤 2**：生成简洁的总结作为最终回答（包括技能名称、功能亮点、适用场景）
+
+  请确保两个步骤都执行完成！
diff --git a/backend/services/model_health_service.py b/backend/services/model_health_service.py
index 78f6413ee..9214a1ffa 100644
--- a/backend/services/model_health_service.py
+++ b/backend/services/model_health_service.py
@@ -3,6 +3,7 @@
 from nexent.core import MessageObserver
 from nexent.core.models import OpenAIModel, OpenAIVLModel
 from nexent.core.models.embedding_model import JinaEmbedding, OpenAICompatibleEmbedding
+from nexent.core.models.rerank_model import OpenAICompatibleRerank
 
 from services.voice_service import get_voice_service
 from consts.const import LOCALHOST_IP, LOCALHOST_NAME, DOCKER_INTERNAL_HOST
@@ -102,7 +103,13 @@ async def _perform_connectivity_check(
             ssl_verify=ssl_verify
         ).check_connectivity()
     elif model_type == "rerank":
-        connectivity = False
+        rerank_model = OpenAICompatibleRerank(
+            model_name=model_name,
+            base_url=model_base_url,
+            api_key=model_api_key,
+            ssl_verify=ssl_verify,
+        )
+        connectivity = await rerank_model.connectivity_check()
     elif model_type == "vlm":
         observer = MessageObserver()
         connectivity = await OpenAIVLModel(
diff --git a/backend/services/model_provider_service.py b/backend/services/model_provider_service.py
index 8c397dc70..dbff17082 100644
--- a/backend/services/model_provider_service.py
+++ b/backend/services/model_provider_service.py
@@ -132,6 +132,11 @@ async def prepare_model_dict(provider: str, model: dict, model_url: str, model_a
             model_dict["base_url"] = f"{model_url.rstrip('/')}/{MODEL_ENGINE_NORTH_PREFIX}/embeddings"
         # The embedding dimension might differ from the provided max_tokens.
         model_dict["max_tokens"] = await embedding_dimension_check(model_dict)
+    elif model["model_type"] == "rerank":
+        if provider == ProviderEnum.DASHSCOPE.value:
+            model_dict["base_url"] = f"{model_url.replace('compatible-mode/v1','api/v1').rstrip('/')}/services/rerank/text-rerank/text-rerank"
+        else:
+            model_dict["base_url"] = f"{model_url.rstrip('/')}/rerank" 
     else:
         # For non-embedding models
         if provider == ProviderEnum.MODELENGINE.value:
diff --git a/backend/services/providers/dashscope_provider.py b/backend/services/providers/dashscope_provider.py
index 4ecbcbb1d..b9fb7ab7b 100644
--- a/backend/services/providers/dashscope_provider.py
+++ b/backend/services/providers/dashscope_provider.py
@@ -58,7 +58,7 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                 "chat": [],  # Maps to "llm"
                 "vlm": [],  # Maps to "vlm"
                 "embedding": [],  # Maps to "embedding" / "multi_embedding"
-                "reranker": [],  # Maps to "reranker"
+                "rerank": [],  # Maps to "rerank"
                 "tts": [],  # Maps to "tts"
                 "stt": []  # Maps to "stt"
             }
@@ -88,10 +88,10 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                     categorized_models['embedding'].append(cleaned_model)
                     continue
 
-                # 2. Reranker
+                # 2. Rerank
                 if 'rerank' in m_id.lower() or '重排序' in desc:
-                    cleaned_model.update({"model_tag": "reranker", "model_type": "reranker"})
-                    categorized_models['reranker'].append(cleaned_model)
+                    cleaned_model.update({"model_tag": "rerank", "model_type": "rerank"})
+                    categorized_models['rerank'].append(cleaned_model)
                     continue
 
                 # 3. STT
diff --git a/backend/services/providers/silicon_provider.py b/backend/services/providers/silicon_provider.py
index 29de51fce..ea41cc95d 100644
--- a/backend/services/providers/silicon_provider.py
+++ b/backend/services/providers/silicon_provider.py
@@ -30,6 +30,8 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                 silicon_url = f"{SILICON_GET_URL}?sub_type=chat"
             elif model_type in ("embedding", "multi_embedding"):
                 silicon_url = f"{SILICON_GET_URL}?sub_type=embedding"
+            elif model_type == "rerank":
+                silicon_url = f"{SILICON_GET_URL}?sub_type=reranker"
             else:
                 silicon_url = SILICON_GET_URL
 
@@ -48,6 +50,10 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                 for item in model_list:
                     item["model_tag"] = "embedding"
                     item["model_type"] = model_type
+            elif model_type == "rerank":
+                for item in model_list:
+                    item["model_tag"] = "rerank"
+                    item["model_type"] = model_type
 
             # Return empty list to indicate successful API call but no models
             if not model_list:
diff --git a/backend/services/providers/tokenpony_provider.py b/backend/services/providers/tokenpony_provider.py
index 42e5d178c..ab4446c1b 100644
--- a/backend/services/providers/tokenpony_provider.py
+++ b/backend/services/providers/tokenpony_provider.py
@@ -47,7 +47,7 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                 "chat": [],       # Maps to "llm"
                 "vlm": [],        # Maps to "vlm"
                 "embedding": [],  # Maps to "embedding" / "multi_embedding"
-                "reranker": [],   # Maps to "reranker"
+                "rerank": [],   # Maps to "rerank"
                 "tts": [],        # Maps to "tts"
                 "stt": []         # Maps to "stt"
             }
@@ -66,10 +66,10 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                     "model_type": "",
                     "max_tokens": DEFAULT_LLM_MAX_TOKENS
                 }
-                # 1. reranker
+                # 1. rerank
                 if 'rerank' in m_id:
-                    cleaned_model.update({"model_tag": "reranker", "model_type": "reranker"})
-                    categorized_models['reranker'].append(cleaned_model)
+                    cleaned_model.update({"model_tag": "rerank", "model_type": "rerank"})
+                    categorized_models['rerank'].append(cleaned_model)
                 #2. embedding
                 elif 'embedding' in m_id or m_id.startswith('bge-'):
                     cleaned_model.update({"model_tag": "embedding", "model_type": "embedding"})
diff --git a/backend/services/tool_configuration_service.py b/backend/services/tool_configuration_service.py
index a0f5b2399..9653b2e10 100644
--- a/backend/services/tool_configuration_service.py
+++ b/backend/services/tool_configuration_service.py
@@ -28,7 +28,7 @@
     check_tool_list_initialized,
 )
 from services.file_management_service import get_llm_model
-from services.vectordatabase_service import get_embedding_model, get_vector_db_core
+from services.vectordatabase_service import get_embedding_model, get_rerank_model, get_vector_db_core
 from database.client import minio_client
 from services.image_service import get_vlm_model
 from utils.tool_utils import get_local_tools_classes, get_local_tools_description_zh
@@ -694,10 +694,32 @@ def _validate_local_tool(
         if tool_name == "knowledge_base_search":
             embedding_model = get_embedding_model(tenant_id=tenant_id)
             vdb_core = get_vector_db_core()
+
+            # Get rerank configuration
+            rerank = instantiation_params.get("rerank", False)
+            rerank_model_name = instantiation_params.get("rerank_model_name", "")
+            rerank_model = None
+            if rerank and rerank_model_name:
+                rerank_model = get_rerank_model(tenant_id=tenant_id, model_name=rerank_model_name)
+
             params = {
                 **instantiation_params,
                 'vdb_core': vdb_core,
                 'embedding_model': embedding_model,
+                'rerank_model': rerank_model,
+            }
+            tool_instance = tool_class(**params)
+        elif tool_name in ["dify_search", "datamate_search"]:
+            # Get rerank configuration for dify and datamate search tools
+            rerank = instantiation_params.get("rerank", False)
+            rerank_model_name = instantiation_params.get("rerank_model_name", "")
+            rerank_model = None
+            if rerank and rerank_model_name:
+                rerank_model = get_rerank_model(tenant_id=tenant_id, model_name=rerank_model_name)
+
+            params = {
+                **instantiation_params,
+                'rerank_model': rerank_model,
             }
             tool_instance = tool_class(**params)
         elif tool_name == "analyze_image":
diff --git a/backend/services/vectordatabase_service.py b/backend/services/vectordatabase_service.py
index de79c812c..cf8f7f98c 100644
--- a/backend/services/vectordatabase_service.py
+++ b/backend/services/vectordatabase_service.py
@@ -21,6 +21,7 @@
 from fastapi import Body, Depends, Path, Query
 from fastapi.responses import StreamingResponse
 from nexent.core.models.embedding_model import OpenAICompatibleEmbedding, JinaEmbedding, BaseEmbedding
+from nexent.core.models.rerank_model import OpenAICompatibleRerank, BaseRerank
 from nexent.vector_database.base import VectorDatabaseCore
 from nexent.vector_database.elasticsearch_core import ElasticSearchCore
 from nexent.vector_database.datamate_core import DataMateCore
@@ -241,6 +242,52 @@ def get_embedding_model(tenant_id: str, model_name: Optional[str] = None):
         return None
 
 
+def get_rerank_model(tenant_id: str, model_name: Optional[str] = None):
+    """
+    Get the rerank model for the tenant, optionally using a specific model name.
+
+    Args:
+        tenant_id: Tenant ID
+        model_name: Optional specific model name to use (format: "model_repo/model_name" or just "model_name")
+                   If provided, will try to find the model in the tenant's model list.
+
+    Returns:
+        Rerank model instance or None
+    """
+    # If model_name is provided, try to find it in the tenant's models
+    if model_name:
+        try:
+            models = get_model_records({"model_type": "rerank"}, tenant_id)
+            for model in models:
+                model_display_name = model.get("model_repo") + "/" + model["model_name"] if model.get("model_repo") else model["model_name"]
+                if model_display_name == model_name:
+                    # Found the model, create rerank model instance
+                    return OpenAICompatibleRerank(
+                        model_name=get_model_name_from_config(model) or "",
+                        base_url=model.get("base_url", ""),
+                        api_key=model.get("api_key", ""),
+                        ssl_verify=model.get("ssl_verify", True),
+                    )
+        except Exception as e:
+            logger.warning(f"Failed to get rerank model by name {model_name}: {e}")
+
+    # Fall back to default rerank model
+    model_config = tenant_config_manager.get_model_config(
+        key="RERANK_ID", tenant_id=tenant_id)
+
+    model_type = model_config.get("model_type", "")
+
+    if model_type == "rerank":
+        return OpenAICompatibleRerank(
+            model_name=get_model_name_from_config(model_config) or "",
+            base_url=model_config.get("base_url", ""),
+            api_key=model_config.get("api_key", ""),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
+    else:
+        return None
+
+
 class ElasticSearchService:
     @staticmethod
     async def full_delete_knowledge_base(index_name: str, vdb_core: VectorDatabaseCore, user_id: str):
diff --git a/backend/utils/prompt_template_utils.py b/backend/utils/prompt_template_utils.py
index b12ba19a5..271c60a0c 100644
--- a/backend/utils/prompt_template_utils.py
+++ b/backend/utils/prompt_template_utils.py
@@ -26,8 +26,6 @@ def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kw
     Returns:
         dict: Loaded prompt template
     """
-    logger.info(
-        f"Getting prompt template for type: {template_type}, language: {language}, kwargs: {kwargs}")
 
     # Define template path mapping
     template_paths = {
@@ -56,6 +54,10 @@ def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kw
         'cluster_summary_reduce': {
             LANGUAGE["ZH"]: 'backend/prompts/cluster_summary_reduce_zh.yaml',
             LANGUAGE["EN"]: 'backend/prompts/cluster_summary_reduce_en.yaml'
+        },
+        'skill_creation_simple': {
+            LANGUAGE["ZH"]: 'backend/prompts/skill_creation_simple_zh.yaml',
+            LANGUAGE["EN"]: 'backend/prompts/skill_creation_simple_en.yaml'
         }
     }
 
@@ -146,3 +148,35 @@ def get_cluster_summary_reduce_prompt_template(language: str = LANGUAGE["ZH"]) -
         dict: Loaded cluster summary reduce prompt template configuration
     """
     return get_prompt_template('cluster_summary_reduce', language)
+
+
+def get_skill_creation_simple_prompt_template(language: str = LANGUAGE["ZH"]) -> Dict[str, str]:
+    """
+    Get skill creation simple prompt template.
+
+    This template is now structured YAML with system_prompt and user_prompt sections.
+
+    Args:
+        language: Language code ('zh' or 'en')
+
+    Returns:
+        Dict[str, str]: Template with keys 'system_prompt' and 'user_prompt'
+    """
+    template_path_map = {
+        LANGUAGE["ZH"]: 'backend/prompts/skill_creation_simple_zh.yaml',
+        LANGUAGE["EN"]: 'backend/prompts/skill_creation_simple_en.yaml'
+    }
+
+    template_path = template_path_map.get(language, template_path_map[LANGUAGE["ZH"]])
+
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    backend_dir = os.path.dirname(current_dir)
+    absolute_template_path = os.path.join(backend_dir, template_path.replace('backend/', ''))
+
+    with open(absolute_template_path, 'r', encoding='utf-8') as f:
+        template_data = yaml.safe_load(f)
+
+    return {
+        "system_prompt": template_data.get("system_prompt", ""),
+        "user_prompt": template_data.get("user_prompt", "")
+    }
diff --git a/doc/docs/.vitepress/config.mts b/doc/docs/.vitepress/config.mts
index 6855a63f7..6ee76ff5d 100644
--- a/doc/docs/.vitepress/config.mts
+++ b/doc/docs/.vitepress/config.mts
@@ -60,10 +60,18 @@ export default defineConfig({
                 text: "Installation & Deployment",
                 link: "/en/quick-start/installation",
               },
+              {
+                text: "Kubernetes Installation & Deployment",
+                link: "/en/quick-start/kubernetes-installation",
+              },
               {
                 text: "Upgrade Guide",
                 link: "/en/quick-start/upgrade-guide",
               },
+              {
+                text: "Kubernetes Upgrade Guide",
+                link: "/en/quick-start/kubernetes-upgrade-guide",
+              },
               { text: "FAQ", link: "/en/quick-start/faq" },
             ],
           },
@@ -279,10 +287,18 @@ export default defineConfig({
             text: "快速开始",
             items: [
               { text: "安装部署", link: "/zh/quick-start/installation" },
+              {
+                text: "Kubernetes 安装与部署",
+                link: "/zh/quick-start/kubernetes-installation",
+              },
               {
                 text: "升级指导",
                 link: "/zh/quick-start/upgrade-guide",
               },
+              {
+                text: "Kubernetes 升级指南",
+                link: "/zh/quick-start/kubernetes-upgrade-guide",
+              },
               { text: "常见问题", link: "/zh/quick-start/faq" },
             ],
           },
diff --git a/doc/docs/en/quick-start/kubernetes-installation.md b/doc/docs/en/quick-start/kubernetes-installation.md
new file mode 100644
index 000000000..44ca3c993
--- /dev/null
+++ b/doc/docs/en/quick-start/kubernetes-installation.md
@@ -0,0 +1,216 @@
+# Kubernetes Installation & Deployment
+
+## 🎯 Prerequisites
+
+| Resource | Minimum | Recommended |
+|----------|---------|-------------|
+| **CPU**  | 4 cores | 8 cores |
+| **RAM**  | 16 GiB | 64 GiB |
+| **Disk** | 100 GiB | 200 GiB |
+| **Architecture** | x86_64 / ARM64 | x86_64 |
+| **Software** | Kubernetes 1.24+, Helm 3+, kubectl configured | Kubernetes 1.28+ |
+
+> **💡 Note**: The recommended configuration of **8 cores and 64 GiB RAM** provides optimal performance for production workloads.
+
+## 🚀 Quick Start
+
+### 1. Prepare Kubernetes Cluster
+
+Ensure your Kubernetes cluster is running and kubectl is configured with cluster access:
+
+```bash
+kubectl cluster-info
+kubectl get nodes
+```
+
+### 2. Clone and Navigate
+
+```bash
+git clone https://github.com/ModelEngine-Group/nexent.git
+cd nexent/k8s/helm
+```
+
+### 3. Deployment
+
+Run the deployment script:
+
+```bash
+./deploy-helm.sh apply
+```
+
+After executing this command, the system will prompt for configuration options:
+
+**Version Selection:**
+- **Speed version (Lightweight & Fast Deployment, Default)**: Quick startup of core features, suitable for individual users and small teams
+- **Full version (Complete Feature Edition)**: Provides enterprise-level tenant management and resource isolation features, includes Supabase authentication
+
+**Image Source Selection:**
+- **Mainland China**: Uses optimized regional mirrors for faster image pulling
+- **General**: Uses standard Docker Hub registries
+
+**Optional Components:**
+- **Terminal Tool**: Enables openssh-server for AI agent shell command execution
+
+### ⚠️ Important Notes
+
+1️⃣ **When deploying v1.8.0 or later for the first time**, you will be prompted to set a password for the `suadmin` super administrator account during the deployment process. This account has the highest system privileges. Please enter your desired password and **save it securely** after creation - it cannot be retrieved later.
+
+2️⃣ Forgot to note the `suadmin` account password? Follow these steps:
+
+```bash
+# Step 1: Delete su account record in Supabase database
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "SELECT id, email FROM auth.users WHERE email='suadmin@nexent.com';"
+# Get the user_id and delete
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "DELETE FROM auth.identities WHERE user_id='your_user_id';"
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "DELETE FROM auth.users WHERE id='your_user_id';"
+
+# Step 2: Delete su account record in nexent database
+kubectl exec -it -n nexent deploy/nexent-postgresql -- psql -U root -d nexent -c \
+  "DELETE FROM nexent.user_tenant_t WHERE user_id='your_user_id';"
+
+# Step 3: Re-deploy and record the su account password
+./deploy-helm.sh apply
+```
+
+### 4. Access Your Installation
+
+When deployment completes successfully:
+
+| Service | Default Address |
+|---------|-----------------|
+| Web Application | http://localhost:30000 |
+| SSH Terminal | localhost:30022 (if enabled) |
+
+Access steps:
+1. Open **http://localhost:30000** in your browser
+2. Log in with the super administrator account
+3. Access tenant resources → Create tenant and tenant administrator
+4. Log in with the tenant administrator account
+5. Refer to the [User Guide](../user-guide/home-page) to develop agents
+
+## 🏗️ Service Architecture
+
+Nexent uses a microservices architecture deployed via Helm charts:
+
+**Application Services:**
+| Service | Description | Default Port |
+|---------|-------------|--------------|
+| nexent-config | Configuration service | 5010 |
+| nexent-runtime | Runtime service | 5010 |
+| nexent-mcp | MCP container service | 5010 |
+| nexent-northbound | Northbound API service | 5010 |
+| nexent-web | Web frontend | 3000 |
+| nexent-data-process | Data processing service | 5012 |
+
+**Infrastructure Services:**
+| Service | Description |
+|---------|-------------|
+| nexent-elasticsearch | Search and indexing engine |
+| nexent-postgresql | Relational database |
+| nexent-redis | Caching layer |
+| nexent-minio | S3-compatible object storage |
+
+**Supabase Services (Full Version Only):**
+| Service | Description |
+|---------|-------------|
+| nexent-supabase-kong | API Gateway |
+| nexent-supabase-auth | Authentication service |
+| nexent-supabase-db | Database service |
+
+**Optional Services:**
+| Service | Description |
+|---------|-------------|
+| nexent-openssh-server | SSH terminal for AI agents |
+
+## 🔌 Port Mapping
+
+| Service | Internal Port | NodePort | Description |
+|---------|---------------|----------|-------------|
+| Web Interface | 3000 | 30000 | Main application access |
+| Northbound API | 5010 | 30013 | Northbound API service |
+| SSH Server | 22 | 30022 | Terminal tool access |
+
+For internal service communication, services use Kubernetes internal DNS (e.g., `http://nexent-config:5010`).
+
+## 💾 Data Persistence
+
+Nexent uses PersistentVolumes for data persistence:
+
+| Data Type | PersistentVolume | Default Host Path |
+|-----------|------------------|-------------------|
+| Elasticsearch | nexent-elasticsearch-pv | `{dataDir}/elasticsearch` |
+| PostgreSQL | nexent-postgresql-pv | `{dataDir}/postgresql` |
+| Redis | nexent-redis-pv | `{dataDir}/redis` |
+| MinIO | nexent-minio-pv | `{dataDir}/minio` |
+| Supabase DB (Full) | nexent-supabase-db-pv | `{dataDir}/supabase-db` |
+
+Default `dataDir` is `/var/lib/nexent-data` (configurable in `values.yaml`).
+
+## 🔧 Deployment Commands
+
+```bash
+# Deploy with interactive prompts
+./deploy-helm.sh apply
+
+# Deploy with mainland China image sources
+./deploy-helm.sh apply --is-mainland Y
+
+# Deploy full version (with Supabase)
+./deploy-helm.sh apply --deployment-version full
+
+# Clean helm state only (fixes stuck releases)
+./deploy-helm.sh clean
+
+# Uninstall but preserve data
+./deploy-helm.sh delete
+
+# Complete uninstall including all data
+./deploy-helm.sh delete-all
+```
+
+## 🔍 Troubleshooting
+
+### Check Pod Status
+
+```bash
+kubectl get pods -n nexent
+kubectl describe pod <pod-name> -n nexent
+```
+
+### View Logs
+
+```bash
+kubectl logs -n nexent -l app=nexent-config
+kubectl logs -n nexent -l app=nexent-web
+kubectl logs -n nexent -l app=nexent-elasticsearch
+```
+
+### Restart Services
+
+```bash
+kubectl rollout restart deployment/nexent-config -n nexent
+kubectl rollout restart deployment/nexent-runtime -n nexent
+```
+
+### Re-initialize Elasticsearch
+
+If Elasticsearch initialization failed:
+
+```bash
+bash init-elasticsearch.sh
+```
+
+### Clean Up Stale PersistentVolumes
+
+```bash
+kubectl delete pv nexent-elasticsearch-pv nexent-postgresql-pv nexent-redis-pv nexent-minio-pv
+```
+
+## 💡 Need Help
+
+- Browse the [FAQ](./faq) for common install issues
+- Drop questions in our [Discord community](https://discord.gg/tb5H3S3wyv)
+- File bugs or feature ideas in [GitHub Issues](https://github.com/ModelEngine-Group/nexent/issues)
diff --git a/doc/docs/en/quick-start/kubernetes-upgrade-guide.md b/doc/docs/en/quick-start/kubernetes-upgrade-guide.md
new file mode 100644
index 000000000..293358d2f
--- /dev/null
+++ b/doc/docs/en/quick-start/kubernetes-upgrade-guide.md
@@ -0,0 +1,180 @@
+# Nexent Kubernetes Upgrade Guide
+
+## 🚀 Upgrade Overview
+
+Follow these steps to upgrade Nexent on Kubernetes safely:
+
+1. Pull the latest code
+2. Execute the Helm deployment script
+3. Open the site to confirm service availability
+
+---
+
+## 🔄 Step 1: Update Code
+
+Before updating, record the current deployment version and data directory information.
+
+- Current Deployment Version Location: `APP_VERSION` in `backend/consts/const.py`
+- Data Directory Location: `global.dataDir` in `k8s/helm/nexent/values.yaml`
+
+**Code downloaded via git**
+
+Update the code using git commands:
+
+```bash
+git pull
+```
+
+**Code downloaded via ZIP package or other means**
+
+1. Re-download the latest code from GitHub and extract it.
+2. Copy the `.deploy.options` file from the `k8s/helm` directory of your previous deployment to the new code directory. (If the file doesn't exist, you can ignore this step).
+
+## 🔄 Step 2: Execute the Upgrade
+
+Navigate to the k8s/helm directory of the updated code and run the deployment script:
+
+```bash
+cd k8s/helm
+./deploy-helm.sh apply
+```
+
+The script will detect your previous deployment settings (version, image source, etc.) from the `.deploy.options` file. If the file is missing, you will be prompted to enter configuration details.
+
+> 💡 Tip
+> If you need to configure voice models (STT/TTS), please edit the corresponding values in `values.yaml` or pass them via command line.
+
+---
+
+## 🌐 Step 3: Verify the Deployment
+
+After deployment:
+
+1. Open `http://localhost:30000` in your browser.
+2. Review the [User Guide](../user-guide/home-page) to validate agent functionality.
+
+---
+
+## 🗄️ Manual Database Update
+
+If some SQL files fail to execute during the upgrade, or if you need to run incremental SQL scripts manually, you can perform the update using the methods below.
+
+### 📋 Find SQL Scripts
+
+SQL migration scripts are located in the repository at:
+
+```
+docker/sql/
+```
+
+Check the [upgrade-guide](./upgrade-guide.md) or release notes to identify which SQL scripts need to be executed for your upgrade path.
+
+### ✅ Method A: Use a SQL Editor (recommended)
+
+1. Open your SQL client and create a new PostgreSQL connection.
+2. Get connection settings from the running PostgreSQL pod:
+
+   ```bash
+   # Get PostgreSQL pod name
+   kubectl get pods -n nexent -l app=nexent-postgresql
+
+   # Port-forward to access PostgreSQL locally
+   kubectl port-forward svc/nexent-postgresql 5433:5432 -n nexent &
+   ```
+
+3. Connection details:
+   - Host: `localhost`
+   - Port: `5433` (forwarded port)
+   - Database: `nexent`
+   - User: `root`
+   - Password: Check in `k8s/helm/nexent/charts/nexent-common/values.yaml`
+
+4. Test the connection. When successful, you should see tables under the `nexent` schema.
+5. Execute the required SQL file(s) in version order.
+
+> ⚠️ Important
+> - Always back up the database first, especially in production.
+> - Run scripts sequentially to avoid dependency issues.
+
+### 🧰 Method B: Use kubectl exec (no SQL client required)
+
+Execute SQL scripts directly via stdin redirection:
+
+1. Get the PostgreSQL pod name:
+
+   ```bash
+   kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}'
+   ```
+
+2. Execute the SQL file directly from your host machine:
+
+   ```bash
+   kubectl exec -i <pod-name> -n nexent -- psql -U root -d nexent < ./sql/v1.1.1_1030-update.sql
+   ```
+
+   Or if you want to see the output interactively:
+
+   ```bash
+   cat ./sql/v1.1.1_1030-update.sql | kubectl exec -i <pod-name> -n nexent -- psql -U root -d nexent
+   ```
+
+**Example - Execute multiple SQL files:**
+
+```bash
+# Get PostgreSQL pod name
+POSTGRES_POD=$(kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}')
+
+# Execute SQL files in order
+kubectl exec -i $POSTGRES_POD -n nexent -- psql -U root -d nexent < ./sql/v1.8.0_xxxxx-update.sql
+kubectl exec -i $POSTGRES_POD -n nexent -- psql -U root -d nexent < ./sql/v2.0.0_0314_add_context_skill_t.sql
+```
+
+> 💡 Tips
+> - Create a backup before running migrations:
+
+   ```bash
+   POSTGRES_POD=$(kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}')
+   kubectl exec nexent/$POSTGRES_POD -n nexent -- pg_dump -U root nexent > backup_$(date +%F).sql
+   ```
+
+> - For Supabase database (full version only), use `nexent-supabase-db` pod instead:
+
+   ```bash
+   SUPABASE_POD=$(kubectl get pods -n nexent -l app=nexent-supabase-db -o jsonpath='{.items[0].metadata.name}')
+   kubectl cp docker/sql/xxx.sql nexent/$SUPABASE_POD:/tmp/update.sql
+   kubectl exec -it nexent/$SUPABASE_POD -n nexent -- psql -U postgres -f /tmp/update.sql
+   ```
+
+---
+
+## 🔍 Troubleshooting
+
+### Check Deployment Status
+
+```bash
+kubectl get pods -n nexent
+kubectl rollout status deployment/nexent-config -n nexent
+```
+
+### View Logs
+
+```bash
+kubectl logs -n nexent -l app=nexent-config --tail=100
+kubectl logs -n nexent -l app=nexent-web --tail=100
+```
+
+### Restart Services After Manual SQL Update（if needed）
+
+If you executed SQL scripts manually, restart the affected services:
+
+```bash
+kubectl rollout restart deployment/nexent-config -n nexent
+kubectl rollout restart deployment/nexent-runtime -n nexent
+```
+
+### Re-initialize Elasticsearch (if needed)
+
+```bash
+cd k8s/helm
+bash init-elasticsearch.sh
+```
diff --git a/doc/docs/zh/opensource-memorial-wall.md b/doc/docs/zh/opensource-memorial-wall.md
index 4c0ced170..e50e3cebe 100644
--- a/doc/docs/zh/opensource-memorial-wall.md
+++ b/doc/docs/zh/opensource-memorial-wall.md
@@ -738,4 +738,6 @@ Nexent 加油！希望能达成所愿！
 
 ::: info BigBen0724 - 2026-03-16
 在体验一众AI工具后，被 Nexent 产品所吸引，希望这一智能体开发平台能赋能我的工作生活！
-:::
+::: 
+    info alex07 - 2026-3-27
+  这个平台为我提供了学习智能体的途径，提升工作效能。感谢！
diff --git a/doc/docs/zh/quick-start/kubernetes-installation.md b/doc/docs/zh/quick-start/kubernetes-installation.md
new file mode 100644
index 000000000..be7857fb2
--- /dev/null
+++ b/doc/docs/zh/quick-start/kubernetes-installation.md
@@ -0,0 +1,216 @@
+# Kubernetes 安装部署
+
+## 🎯 系统要求
+
+| 资源 | 最低要求 | 推荐配置 |
+|----------|---------|-------------|
+| **CPU**  | 4 核 | 8 核 |
+| **内存**  | 16 GiB | 64 GiB |
+| **磁盘** | 100 GiB | 200 GiB |
+| **架构** | x86_64 / ARM64 |
+| **软件** | Kubernetes 1.24+, Helm 3+, kubectl 已配置 | Kubernetes 1.28+ |
+
+> **💡 注意**：推荐的 **8 核 64 GiB 内存** 配置可确保生产环境下的最佳性能。
+
+## 🚀 快速开始
+
+### 1. 准备 Kubernetes 集群
+
+确保 Kubernetes 集群正常运行，且 kubectl 已配置好集群访问权限：
+
+```bash
+kubectl cluster-info
+kubectl get nodes
+```
+
+### 2. 克隆并进入目录
+
+```bash
+git clone https://github.com/ModelEngine-Group/nexent.git
+cd nexent/k8s/helm
+```
+
+### 3. 部署
+
+运行部署脚本：
+
+```bash
+./deploy-helm.sh apply
+```
+
+执行此命令后，系统会提示您选择配置选项：
+
+**版本选择:**
+- **Speed version（轻量快速部署，默认）**: 快速启动核心功能，适合个人用户和小团队使用
+- **Full version（完整功能版）**: 提供企业级租户管理和资源隔离等高级功能，包含 Supabase 认证服务
+
+**镜像源选择:**
+- **中国大陆**: 使用优化的区域镜像源，加快镜像拉取速度
+- **通用**: 使用标准 Docker Hub 镜像源
+
+**可选组件:**
+- **终端工具**: 启用 openssh-server 供 AI 智能体执行 shell 命令
+
+### ⚠️ 重要提示
+
+1️⃣ **首次部署 v1.8.0 及以上版本时**，部署过程中系统会提示您设置 `suadmin` 超级管理员账号的密码。该账号为系统最高权限账户，请输入您想要的密码并**妥善保存**——密码创建后无法再次找回。
+
+2️⃣ 忘记记录 `suadmin` 账号密码？请按照以下步骤操作：
+
+```bash
+# Step 1: 在 Supabase 数据库中删除 su 账号记录
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "SELECT id, email FROM auth.users WHERE email='suadmin@nexent.com';"
+# 获取 user_id 后执行删除
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "DELETE FROM auth.identities WHERE user_id='your_user_id';"
+kubectl exec -it -n nexent deploy/nexent-supabase-db -- psql -U postgres -c \
+  "DELETE FROM auth.users WHERE id='your_user_id';"
+
+# Step 2: 在 nexent 数据库中删除 su 账号记录
+kubectl exec -it -n nexent deploy/nexent-postgresql -- psql -U root -d nexent -c \
+  "DELETE FROM nexent.user_tenant_t WHERE user_id='your_user_id';"
+
+# Step 3: 重新部署并记录 su 账号密码
+./deploy-helm.sh apply
+```
+
+### 4. 访问您的安装
+
+部署成功完成后：
+
+| 服务 | 默认地址 |
+|---------|-----------------|
+| Web 应用 | http://localhost:30000 |
+| SSH 终端 | localhost:30022（已启用时） |
+
+访问步骤：
+1. 在浏览器中打开 **http://localhost:30000**
+2. 登录超级管理员账号
+3. 访问租户资源 → 创建租户及租户管理员
+4. 登录租户管理员账号
+5. 参考 [用户指南](../user-guide/home-page) 进行智能体的开发
+
+## 🏗️ 服务架构
+
+Nexent 采用微服务架构，通过 Helm Chart 进行部署：
+
+**应用服务:**
+| 服务 | 描述 | 默认端口 |
+|---------|-------------|--------------|
+| nexent-config | 配置服务 | 5010 |
+| nexent-runtime | 运行时服务 | 5014 |
+| nexent-mcp | MCP 容器服务 | 5011 |
+| nexent-northbound | 北向 API 服务 | 5013 |
+| nexent-web | Web 前端 | 3000 |
+| nexent-data-process | 数据处理服务 | 5012 |
+
+**基础设施服务:**
+| 服务 | 描述 |
+|---------|-------------|
+| nexent-elasticsearch | 搜索引擎和索引服务 |
+| nexent-postgresql | 关系型数据库 |
+| nexent-redis | 缓存层 |
+| nexent-minio | S3 兼容对象存储 |
+
+**Supabase 服务（完整版独有）:**
+| 服务 | 描述 |
+|---------|-------------|
+| nexent-supabase-kong | API 网关 |
+| nexent-supabase-auth | 认证服务 |
+| nexent-supabase-db | 数据库服务 |
+
+**可选服务:**
+| 服务 | 描述 |
+|---------|-------------|
+| nexent-openssh-server | AI 智能体 SSH 终端 |
+
+## 🔌 端口映射
+
+| 服务 | 内部端口 | NodePort | 描述 |
+|---------|---------------|----------|-------------|
+| Web 界面 | 3000 | 30000 | 主应用程序访问 |
+| Northbound API | 5010 | 30013 | 北向 API 服务 |
+| SSH 服务器 | 22 | 30022 | 终端工具访问 |
+
+内部服务通信使用 Kubernetes 内部 DNS（例如 `http://nexent-config:5010`）。
+
+## 💾 数据持久化
+
+Nexent 使用 PersistentVolume 进行数据持久化：
+
+| 数据类型 | PersistentVolume | 默认宿主机路径 |
+|-----------|------------------|-------------------|
+| Elasticsearch | nexent-elasticsearch-pv | `{dataDir}/elasticsearch` |
+| PostgreSQL | nexent-postgresql-pv | `{dataDir}/postgresql` |
+| Redis | nexent-redis-pv | `{dataDir}/redis` |
+| MinIO | nexent-minio-pv | `{dataDir}/minio` |
+| Supabase DB（完整版）| nexent-supabase-db-pv | `{dataDir}/supabase-db` |
+
+默认 `dataDir` 为 `/var/lib/nexent-data`（可在 `values.yaml` 中配置）。
+
+## 🔧 部署命令
+
+```bash
+# 交互式部署
+./deploy-helm.sh apply
+
+# 使用中国大陆镜像源部署
+./deploy-helm.sh apply --is-mainland Y
+
+# 部署完整版本（包含 Supabase）
+./deploy-helm.sh apply --deployment-version full
+
+# 仅清理 Helm 状态（修复卡住的发布）
+./deploy-helm.sh clean
+
+# 卸载但保留数据
+./deploy-helm.sh delete
+
+# 完全卸载包括所有数据
+./deploy-helm.sh delete-all
+```
+
+## 🔍 故障排查
+
+### 查看 Pod 状态
+
+```bash
+kubectl get pods -n nexent
+kubectl describe pod <pod-name> -n nexent
+```
+
+### 查看日志
+
+```bash
+kubectl logs -n nexent -l app=nexent-config
+kubectl logs -n nexent -l app=nexent-web
+kubectl logs -n nexent -l app=nexent-elasticsearch
+```
+
+### 重启服务
+
+```bash
+kubectl rollout restart deployment/nexent-config -n nexent
+kubectl rollout restart deployment/nexent-runtime -n nexent
+```
+
+### 重新初始化 Elasticsearch
+
+如果 Elasticsearch 初始化失败：
+
+```bash
+bash init-elasticsearch.sh
+```
+
+### 清理过期的 PersistentVolume
+
+```bash
+kubectl delete pv nexent-elasticsearch-pv nexent-postgresql-pv nexent-redis-pv nexent-minio-pv
+```
+
+## 💡 需要帮助
+
+- 浏览 [常见问题](./faq) 了解常见安装问题
+- 在我们的 [Discord 社区](https://discord.gg/tb5H3S3wyv) 提问
+- 在 [GitHub Issues](https://github.com/ModelEngine-Group/nexent/issues) 中提交错误报告或功能建议
diff --git a/doc/docs/zh/quick-start/kubernetes-upgrade-guide.md b/doc/docs/zh/quick-start/kubernetes-upgrade-guide.md
new file mode 100644
index 000000000..43f5c1d49
--- /dev/null
+++ b/doc/docs/zh/quick-start/kubernetes-upgrade-guide.md
@@ -0,0 +1,180 @@
+# Nexent Kubernetes 升级指导
+
+## 🚀 升级流程概览
+
+在 Kubernetes 上升级 Nexent 时，建议依次完成以下几个步骤：
+
+1. 拉取最新代码
+2. 执行 Helm 部署脚本
+3. 打开站点确认服务可用
+
+---
+
+## 🔄 步骤一：更新代码
+
+更新之前，先记录下当前部署的版本和数据目录信息。
+
+- 当前部署版本信息的位置：`backend/consts/const.py` 中的 `APP_VERSION`
+- 数据目录信息的位置：`k8s/helm/nexent/values.yaml` 中的 `global.dataDir`
+
+**git 方式下载的代码**
+
+通过 git 指令更新代码：
+
+```bash
+git pull
+```
+
+**zip 包等方式下载的代码**
+
+1. 需要去 GitHub 上重新下载一份最新代码，并解压缩。
+2. 将之前执行部署脚本目录下 `k8s/helm` 目录中的 `.deploy.options` 文件拷贝到新代码目录的 `k8s/helm` 目录中。（如果不存在该文件则忽略此步骤）。
+
+## 🔄 步骤二：执行升级
+
+进入更新后代码目录的 `k8s/helm` 目录，执行部署脚本：
+
+```bash
+cd k8s/helm
+./deploy-helm.sh apply
+```
+
+脚本会自动检测您之前的部署设置（版本、镜像源等）。如果 `.deploy.options` 文件不存在，系统会提示您输入配置信息。
+
+> 💡 提示
+> - 若需配置语音模型（STT/TTS），请在对应的 `values.yaml` 中修改相关配置，或通过命令行参数传入。
+
+---
+
+## 🌐 步骤三：验证部署
+
+部署完成后：
+
+1. 在浏览器打开 `http://localhost:30000`
+2. 参考 [用户指南](../user-guide/home-page) 完成智能体配置与验证
+
+---
+
+## 🗄️ 手动更新数据库
+
+升级时如果存在部分 SQL 文件执行失败，或需要手动执行增量 SQL 脚本时，可以通过以下方法进行更新。
+
+### 📋 查找 SQL 脚本
+
+SQL 迁移脚本位于仓库的：
+
+```
+docker/sql/
+```
+
+请查看 [升级指南](./upgrade-guide.md) 或版本发布说明，确认需要执行哪些 SQL 脚本。
+
+### ✅ 方法一：使用 SQL 编辑器（推荐）
+
+1. 打开 SQL 编辑器，新建 PostgreSQL 连接。
+2. 从正在运行的 PostgreSQL Pod 中获取连接信息：
+
+   ```bash
+   # 获取 PostgreSQL Pod 名称
+   kubectl get pods -n nexent -l app=nexent-postgresql
+
+   # 端口转发以便本地访问 PostgreSQL
+   kubectl port-forward svc/nexent-postgresql 5433:5432 -n nexent &
+   ```
+
+3. 连接信息：
+   - Host: `localhost`
+   - Port: `5433`（转发的端口）
+   - Database: `nexent`
+   - User: `root`
+   - Password: 可在 `k8s/helm/nexent/charts/nexent-common/values.yaml` 中查看
+
+4. 填写连接信息后测试连接，确认成功后可在 `nexent` schema 中查看所有表。
+5. 按版本顺序执行所需的 SQL 文件。
+
+> ⚠️ 注意事项
+> - 升级前请备份数据库，生产环境尤为重要。
+> - SQL 脚本需按时间顺序执行，避免依赖冲突。
+
+### 🧰 方法二：使用 kubectl exec（无需客户端）
+
+通过 stdin 重定向直接在主机上执行 SQL 脚本：
+
+1. 获取 PostgreSQL Pod 名称：
+
+   ```bash
+   kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}'
+   ```
+
+2. 直接从主机执行 SQL 文件：
+
+   ```bash
+   kubectl exec -i <pod-name> -n nexent -- psql -U root -d nexent < ./sql/v1.1.1_1030-update.sql
+   ```
+
+   或者如果想交互式查看输出：
+
+   ```bash
+   cat ./sql/v1.1.1_1030-update.sql | kubectl exec -i <pod-name> -n nexent -- psql -U root -d nexent
+   ```
+
+**示例 - 依次执行多个 SQL 文件：**
+
+```bash
+# 获取 PostgreSQL Pod 名称
+POSTGRES_POD=$(kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}')
+
+# 按顺序执行 SQL 文件
+kubectl exec -i $POSTGRES_POD -n nexent -- psql -U root -d nexent < ./sql/v1.8.0_xxxxx-update.sql
+kubectl exec -i $POSTGRES_POD -n nexent -- psql -U root -d nexent < ./sql/v2.0.0_0314_add_context_skill_t.sql
+```
+
+> 💡 提示
+> - 执行前建议先备份数据库：
+
+   ```bash
+   POSTGRES_POD=$(kubectl get pods -n nexent -l app=nexent-postgresql -o jsonpath='{.items[0].metadata.name}')
+   kubectl exec nexent/$POSTGRES_POD -n nexent -- pg_dump -U root nexent > backup_$(date +%F).sql
+   ```
+
+> - 对于 Supabase 数据库（仅完整版本），请使用 `nexent-supabase-db` Pod：
+
+   ```bash
+   SUPABASE_POD=$(kubectl get pods -n nexent -l app=nexent-supabase-db -o jsonpath='{.items[0].metadata.name}')
+   kubectl cp docker/sql/xxx.sql nexent/$SUPABASE_POD:/tmp/update.sql
+   kubectl exec -it nexent/$SUPABASE_POD -n nexent -- psql -U postgres -f /tmp/update.sql
+   ```
+
+---
+
+## 🔍 故障排查
+
+### 查看部署状态
+
+```bash
+kubectl get pods -n nexent
+kubectl rollout status deployment/nexent-config -n nexent
+```
+
+### 查看日志
+
+```bash
+kubectl logs -n nexent -l app=nexent-config --tail=100
+kubectl logs -n nexent -l app=nexent-web --tail=100
+```
+
+### 手动 SQL 更新后重启服务（如需要）
+
+如果您手动执行了 SQL 脚本，需要重启受影响的服务：
+
+```bash
+kubectl rollout restart deployment/nexent-config -n nexent
+kubectl rollout restart deployment/nexent-runtime -n nexent
+```
+
+### 重新初始化 Elasticsearch（如需要）
+
+```bash
+cd k8s/helm
+bash init-elasticsearch.sh
+```
diff --git a/doc/docs/zh/user-guide/agent-development.md b/doc/docs/zh/user-guide/agent-development.md
index cb4b4055d..67d3c8311 100644
--- a/doc/docs/zh/user-guide/agent-development.md
+++ b/doc/docs/zh/user-guide/agent-development.md
@@ -130,10 +130,11 @@
      - 检索的模式 `search_mode`（默认为 `hybrid`）
      - 目标检索的知识库列表 `index_names`，如 `["医疗", "维生素知识大全"]`
      - 若不输入 `index_names`，则默认检索知识库页面所选中的全部知识库
+     - 是否启用重排模型（默认为 `false`），启用后配置重排模型，实现对检索结果的重排优化 
 6. 输入完成后点击"执行测试"开始测试，并在下方查看测试结果
 
 <div style="display: flex; justify-content: left;">
-  <img src="./assets/agent-development/tool-test-run.png" style="width: 80%; height: auto;" />
+  <img src="./assets/agent-development/tool-test-run-1.png" style="width: 80%; height: auto;" />
 </div>
 
 ## 📝 描述业务逻辑
diff --git a/doc/docs/zh/user-guide/assets/agent-development/tool-test-run-1.png b/doc/docs/zh/user-guide/assets/agent-development/tool-test-run-1.png
new file mode 100644
index 000000000..e0cb534f2
Binary files /dev/null and b/doc/docs/zh/user-guide/assets/agent-development/tool-test-run-1.png differ
diff --git a/doc/docs/zh/user-guide/assets/model-management/select-model-4.png b/doc/docs/zh/user-guide/assets/model-management/select-model-4.png
new file mode 100644
index 000000000..78ed60633
Binary files /dev/null and b/doc/docs/zh/user-guide/assets/model-management/select-model-4.png differ
diff --git a/doc/docs/zh/user-guide/local-tools/search-tools.md b/doc/docs/zh/user-guide/local-tools/search-tools.md
index 4b71833c3..9c0ded771 100644
--- a/doc/docs/zh/user-guide/local-tools/search-tools.md
+++ b/doc/docs/zh/user-guide/local-tools/search-tools.md
@@ -31,6 +31,8 @@ title: 搜索工具
   - `query`：检索问题，必填。
   - `search_mode`：`hybrid`（默认，混合召回）、`accurate`（文本模糊匹配）、`semantic`（向量语义）。
   - `index_names`：指定要搜索的知识库名称列表（可用用户侧名称或内部索引名），可选。
+  - `enable_rerank`：是否启用重排序，默认 False。开启后会对检索结果进行二次排序，提升结果相关性。
+  - `rerank_model`：重排序使用的模型，默认为系统配置的 rerank 模型。`enable_rerank` 为 True 时生效。
 - 返回匹配片段的标题、路径/URL、来源类型、得分等。
 - 若未选择知识库，会提示"无可用知识库"。
 
@@ -44,6 +46,8 @@ title: 搜索工具
   - `threshold`：相似度阈值，默认 0.2。
   - `index_names`：指定要搜索的知识库名称列表，可选。
   - `kb_page` / `kb_page_size`：分页获取 DataMate 知识库列表。
+  - `enable_rerank`：是否启用重排序，默认 False。开启后会对检索结果进行二次排序，提升结果相关性。
+  - `rerank_model`：重排序使用的模型，默认为系统配置的 rerank 模型。`enable_rerank` 为 True 时生效。
 - 返回包含文件名、下载链接、得分等结构化结果。
 
 ### dify_search
@@ -58,6 +62,8 @@ title: 搜索工具
 - **检索参数**：
   - `query`：检索问题，必填。
   - `search_method`：搜索方法，选项：`keyword_search`、`semantic_search`、`full_text_search`、`hybrid_search`，默认 `semantic_search`。
+  - `enable_rerank`：是否启用重排序，默认 False。开启后会对检索结果进行二次排序，提升结果相关性。
+  - `rerank_model`：重排序使用的模型，默认为系统配置的 rerank 模型。`enable_rerank` 为 True 时生效。
 - 返回匹配片段的标题、内容、得分等。
 
 ### exa_search / tavily_search / linkup_search
@@ -79,7 +85,8 @@ title: 搜索工具
 1. **选择数据源**：私有资料用 `knowledge_base_search`、`datamate_search` 或 `dify_search`；实时公开信息用 Exa/Tavily/Linkup。
 2. **设置检索模式/数量**：知识库可在 `search_mode` 之间切换；公网搜索可调整 `max_results` 与是否启用图片过滤。
 3. **限定范围**：需要特定知识库时填写 `index_names`，避免无关结果；DataMate 可通过阈值与 top_k 控制结果精度与数量。
-4. **结果利用**：返回为 JSON，可直接用于回答、摘要或后续引用；包含 cite 索引便于引用管理。
+4. **启用重排序（可选）**：如需提升检索结果相关性，可设置 `enable_rerank: true`，并通过 `rerank_top_n` 和 `rerank_model` 调整重排序效果。
+5. **结果利用**：返回为 JSON，可直接用于回答、摘要或后续引用；包含 cite 索引便于引用管理。
 
 ## 🛡️ 安全与最佳实践
 
diff --git a/doc/docs/zh/user-guide/model-management.md b/doc/docs/zh/user-guide/model-management.md
index b715ebc1a..46c1b25b4 100644
--- a/doc/docs/zh/user-guide/model-management.md
+++ b/doc/docs/zh/user-guide/model-management.md
@@ -52,7 +52,7 @@ Nexent支持与ModelEngine平台的无缝对接
 1. **添加自定义模型**
    - 点击"添加自定义模型"按钮，进入添加模型弹窗。
 2. **选择模型类型**
-   - 点击模型类型下拉框，选择要添加的模型类型（大语言模型/向量化模型/视觉语言模型）。
+   - 点击模型类型下拉框，选择要添加的模型类型（大语言模型/向量化模型/视觉语言模型/重排模型）。
 3. **配置模型参数**
    - **模型名称（必填）**：输入请求体中的模型名称。
    - **展示名称**：可为模型设置一个展示名称，默认与模型名称相同。
@@ -82,7 +82,7 @@ Nexent支持与ModelEngine平台的无缝对接
 2. **选择模型提供商**
    - 点击模型提供商下拉框，选择模型提供商。
 3. **选择模型类型**
-   - 点击模型类型下拉框，选择要添加的模型类型（大语言模型/向量化模型/视觉语言模型）。
+   - 点击模型类型下拉框，选择要添加的模型类型（大语言模型/向量化模型/视觉语言模型/重排模型）。
 4. **输入API Key（必填）**
    - 输入您的API密钥。
 5. **获取模型**
@@ -150,6 +150,10 @@ Nexent支持与ModelEngine平台的无缝对接
   <img src="./assets/model-management/vector-model.png" style="width: 50%; height: 50%;" />
 </div>
 
+#### 重排模型
+重排模型用于初筛后的文档进行语义匹配与评分，确保最相关的核心答案能够排在首位，以提升检索的准确性和效率。配置合适的重排模型，可以显著提升知识库的检索效果。
+
+- 点击重排模型下拉框，从已添加的重排模型中选择一个。
 
 
 #### 多模态模型
@@ -161,6 +165,7 @@ Nexent支持与ModelEngine平台的无缝对接
 <div style="display: flex; gap: 8px;">
   <img src="./assets/model-management/select-model-1.png" style="width: 30%; height: 100%;" />
   <img src="./assets/model-management/select-model-2.png" style="width: 30%; height: 100%;" />
+  <img src="./assets/model-management/select-model-4.png" style="width: 30%; height: 100%;" />
   <img src="./assets/model-management/select-model-3.png" style="width: 30%; height: 100%;" />
 </div>
 
@@ -215,6 +220,8 @@ Nexent 支持任何 **遵循OpenAI API规范** 的大语言模型供应商，包
 
 使用与大语言模型相同的API Key，但模型URL一般会有所差异，一般以`/v1/embeddings`为结尾，同时指定向量模型名称，如硅基流动提供的**BAAI/bge-m3**。
 
+#### 🔃 重排模型
+使用与大语言模型相同的API Key，但模型URL一般会有所差异，一般以`/v1/rerank`为结尾。
 #### 🎤 语音模型
 
 目前仅支持火山引擎语音，且需要在`.env`中进行配置
diff --git a/docker/.env.example b/docker/.env.example
index d03cf6113..b0ba46ef4 100644
--- a/docker/.env.example
+++ b/docker/.env.example
@@ -155,4 +155,4 @@ LLM_SLOW_REQUEST_THRESHOLD_SECONDS=5.0
 LLM_SLOW_TOKEN_RATE_THRESHOLD=10.0
 
 # Market Backend Address
-MARKET_BACKEND=https://market.nexent.tech
+MARKET_BACKEND=http://60.204.251.153:8010
diff --git a/docker/docker-compose.prod.yml b/docker/docker-compose.prod.yml
index 8eef651ae..6db803215 100644
--- a/docker/docker-compose.prod.yml
+++ b/docker/docker-compose.prod.yml
@@ -188,7 +188,7 @@ services:
       - WS_BACKEND=ws://nexent-runtime:5014
       - RUNTIME_HTTP_BACKEND=http://nexent-runtime:5014
       - MINIO_ENDPOINT=http://nexent-minio:9000
-      - MARKET_BACKEND=https://market.nexent.tech
+      - MARKET_BACKEND=http://60.204.251.153:8010
     logging:
       driver: "json-file"
       options:
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index 321f29665..4addc680b 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -205,7 +205,7 @@ services:
       - WS_BACKEND=ws://nexent-runtime:5014
       - RUNTIME_HTTP_BACKEND=http://nexent-runtime:5014
       - MINIO_ENDPOINT=http://nexent-minio:9000
-      - MARKET_BACKEND=https://market.nexent.tech
+      - MARKET_BACKEND=http://60.204.251.153:8010
       - MODEL_ENGINE_ENABLED=${MODEL_ENGINE_ENABLED:-false}
     logging:
       driver: "json-file"
diff --git a/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx b/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
index 46307a0d2..0a6892487 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/SkillBuildModal.tsx
@@ -2,7 +2,6 @@
 
 import { useState, useEffect, useMemo, useRef } from "react";
 import { useTranslation } from "react-i18next";
-import ReactMarkdown from "react-markdown";
 import {
   Modal,
   Tabs,
@@ -13,7 +12,6 @@ import {
   Select,
   message,
   Flex,
-  Progress,
   Row,
   Col,
   Spin,
@@ -24,10 +22,9 @@ import {
   Trash2,
   MessagesSquare,
   HardDriveUpload,
+  Loader2,
 } from "lucide-react";
-import { getAgentByName } from "@/services/agentConfigService";
-import { conversationService } from "@/services/conversationService";
-import { extractSkillInfo } from "@/lib/skillFileUtils";
+import { extractSkillInfo, extractSkillInfoFromContent } from "@/lib/skillFileUtils";
 import {
   MAX_RECENT_SKILLS,
   THINKING_STEPS_ZH,
@@ -38,12 +35,13 @@ import {
   fetchSkillsList,
   submitSkillForm,
   submitSkillFromFile,
-  processSkillStream,
-  deleteSkillCreatorTempFile,
   findSkillByName,
   searchSkillsByName as searchSkillsByNameUtil,
+  createSimpleSkillStream,
+  clearChatAndTempFile,
   type SkillListItem,
 } from "@/services/skillService";
+import { MarkdownRenderer } from "@/components/ui/markdownRenderer";
 import log from "@/lib/logger";
 
 const { TextArea } = Input;
@@ -61,14 +59,7 @@ export default function SkillBuildModal({
 }: SkillBuildModalProps) {
   const { t } = useTranslation("common");
   const [form] = Form.useForm<SkillFormData>();
-  // TODO: [FEATURE] Re-enable interactive skill creation tab
-  // Reason: Interactive tab depends on skill_creator agent which may not be available in all deployments
-  // When to re-enable:
-  //   1. Ensure skill_creator agent is properly configured and deployed
-  //   2. Verify conversationService works correctly with the agent
-  //   3. Test the full chat-to-form workflow end-to-end
-  //   4. Remove this TODO and restore the interactive tab in tabItems
-  const [activeTab, setActiveTab] = useState<string>("upload");
+  const [activeTab, setActiveTab] = useState<string>("interactive");
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [allSkills, setAllSkills] = useState<SkillListItem[]>([]);
   const [searchResults, setSearchResults] = useState<SkillListItem[]>([]);
@@ -86,13 +77,20 @@ export default function SkillBuildModal({
   const [isThinkingVisible, setIsThinkingVisible] = useState(false);
   const [interactiveSkillName, setInteractiveSkillName] = useState<string>("");
   const chatContainerRef = useRef<HTMLDivElement>(null);
+  const contentTextAreaId = useRef<string>("skill-content-textarea-" + Date.now());
 
-  // skill_creator agent state (cached after first lookup)
-  const [skillCreatorAgentId, setSkillCreatorAgentId] = useState<number | null>(null);
-  const skillCreatorAgentIdRef = useRef<number | null>(null);
+  // Content input streaming state
+  const [formStreamingContent, setFormStreamingContent] = useState<string>("");
+  const [isContentStreaming, setIsContentStreaming] = useState(false);
+  const [thinkingStreamingContent, setThinkingStreamingContent] = useState<string>("");
+  const [summaryStreamingContent, setSummaryStreamingContent] = useState<string>("");
+  const [isSummaryVisible, setIsSummaryVisible] = useState(false);
 
   // Track if component is mounted to prevent state updates after unmount
   const isMountedRef = useRef(true);
+  const currentAssistantIdRef = useRef<string>("");
+  // Track if streaming is complete to prevent late onFormContent callbacks from overwriting cleaned content
+  const isStreamingCompleteRef = useRef(false);
 
   // Name input dropdown control
   const [isNameDropdownOpen, setIsNameDropdownOpen] = useState(false);
@@ -128,11 +126,10 @@ export default function SkillBuildModal({
     };
   }, [isOpen]);
 
-  // TODO: [FEATURE] Update setActiveTab("upload") when interactive tab is re-enabled
   useEffect(() => {
     if (!isOpen) {
       form.resetFields();
-      setActiveTab("upload");
+      setActiveTab("interactive");
       setSelectedSkillName("");
       setUploadFile(null);
       setSearchResults([]);
@@ -144,11 +141,15 @@ export default function SkillBuildModal({
       setIsCreateMode(true);
       setUploadExtractingName(false);
       setUploadExtractedSkillName("");
-      setSkillCreatorAgentId(null);
-      skillCreatorAgentIdRef.current = null;
       setThinkingStep(0);
       setThinkingDescription("");
       setIsThinkingVisible(false);
+      setFormStreamingContent("");
+      setThinkingStreamingContent("");
+      setSummaryStreamingContent("");
+      setIsSummaryVisible(false);
+      setIsContentStreaming(false);
+      currentAssistantIdRef.current = "";
     }
   }, [isOpen, form]);
 
@@ -160,6 +161,27 @@ export default function SkillBuildModal({
     };
   }, []);
 
+  // Sync streaming content to the current assistant chat message for real-time display.
+  // Show thinking content while thinking is visible, then switch to summary.
+  useEffect(() => {
+    if (!currentAssistantIdRef.current) return;
+    const displayContent = isSummaryVisible ? summaryStreamingContent : thinkingStreamingContent;
+    if (!displayContent) return;
+    setChatMessages((prev) =>
+      prev.map((msg) =>
+        msg.id === currentAssistantIdRef.current
+          ? { ...msg, content: displayContent }
+          : msg
+      )
+    );
+  }, [thinkingStreamingContent, summaryStreamingContent, isSummaryVisible]);
+
+  // Sync formStreamingContent to the form content field for real-time display
+  useEffect(() => {
+    if (!formStreamingContent) return;
+    form.setFieldValue("content", formStreamingContent);
+  }, [formStreamingContent, form]);
+
   // Detect create/update mode when skill name changes
   useEffect(() => {
     const nameValue = interactiveSkillName.trim();
@@ -238,7 +260,7 @@ export default function SkillBuildModal({
       form.setFieldsValue({
         name: skill.name,
         description: skill.description || "",
-        source: skill.source || "Custom",
+        source: skill.source || "自定义",
         content: skill.content || "",
       });
     }
@@ -261,11 +283,8 @@ export default function SkillBuildModal({
     }, 200);
   };
 
-  // Cleanup temp file when modal is closed
-  const handleModalClose = async () => {
-    if (activeTab === "interactive" && chatMessages.length > 0) {
-      await deleteSkillCreatorTempFile();
-    }
+  // Cleanup when modal is closed
+  const handleModalClose = () => {
     onCancel();
   };
 
@@ -313,19 +332,6 @@ export default function SkillBuildModal({
     }
   };
 
-  // Resolve skill_creator agent
-  const resolveSkillCreatorAgent = async (): Promise<number | null> => {
-    if (skillCreatorAgentIdRef.current !== null) {
-      const cached = skillCreatorAgentIdRef.current;
-      return cached < 0 ? null : cached;
-    }
-    const result = await getAgentByName("skill_creator");
-    if (!result) return null;
-    skillCreatorAgentIdRef.current = -result.agent_id;
-    setSkillCreatorAgentId(result.agent_id);
-    return result.agent_id;
-  };
-
   // Handle chat send for interactive creation
   const handleChatSend = async () => {
     if (!chatInput.trim() || isChatLoading) return;
@@ -333,6 +339,15 @@ export default function SkillBuildModal({
     const currentInput = chatInput.trim();
     setChatInput("");
 
+    // Read current form fields to provide context to the model
+    const formValues = form.getFieldsValue();
+    const formContext = [
+      formValues.name ? `当前技能名称：${formValues.name}` : "",
+      formValues.description ? `当前技能描述：${formValues.description}` : "",
+      formValues.tags?.length ? `当前标签：${formValues.tags.join(", ")}` : "",
+      formValues.content ? `当前内容：\n${formValues.content}` : "",
+    ].filter(Boolean).join("\n\n");
+
     const userMessage: ChatMessage = {
       id: Date.now().toString(),
       role: "user",
@@ -342,123 +357,119 @@ export default function SkillBuildModal({
 
     setChatMessages((prev) => [...prev, userMessage]);
     setIsChatLoading(true);
-    setThinkingStep(0);
-    setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === 0)?.description || "");
+    setThinkingStep(1);
+    setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === 1)?.description || "生成技能内容中 ...");
     setIsThinkingVisible(true);
 
+    // Clear content input before streaming
+    form.setFieldValue("content", "");
+    setFormStreamingContent("");
+    setThinkingStreamingContent("");
+    setSummaryStreamingContent("");
+    setIsSummaryVisible(false);
+    setIsContentStreaming(true);
+    // Reset streaming complete flag
+    isStreamingCompleteRef.current = false;
+
     const assistantId = (Date.now() + 1).toString();
+
     setChatMessages((prev) => [
       ...prev,
       { id: assistantId, role: "assistant", content: "", timestamp: new Date() },
     ]);
 
-    try {
-      const agentId = await resolveSkillCreatorAgent();
-      if (!agentId) {
-        throw new Error("skill_creator agent not found");
-      }
+    // Track current assistant message ID for streaming updates
+    currentAssistantIdRef.current = assistantId;
 
-      const history = chatMessages.map((msg) => ({
-        role: msg.role === "user" ? "user" : "assistant",
-        content: msg.content,
-      }));
+    try {
+      // Build user prompt with form context
+      const userPrompt = formContext
+        ? `用户需求：${currentInput}\n\n${formContext}`
+        : `用户需求：${currentInput}`;
 
-      const reader = await conversationService.runAgent(
+      await createSimpleSkillStream(
+        { user_request: userPrompt },
         {
-          query: currentInput,
-          conversation_id: 0,
-          history,
-          agent_id: agentId,
-          is_debug: true,
-        },
-        undefined as unknown as AbortSignal
-      );
-
-      await processSkillStream(
-        reader,
-        (step, description) => {
-          setThinkingStep(step);
-          setThinkingDescription(description);
-        },
-        setIsThinkingVisible,
-        async (finalAnswer) => {
-          if (!isMountedRef.current) return;
-
-          setChatMessages((prev) =>
-            prev.map((msg) =>
-              msg.id === assistantId ? { ...msg, content: finalAnswer } : msg
-            )
-          );
-
-          const { parseSkillDraft } = await import("@/lib/skillFileUtils");
-          const skillDraft = parseSkillDraft(finalAnswer);
-
-          if (skillDraft) {
-            form.setFieldValue("name", skillDraft.name);
-            form.setFieldValue("description", skillDraft.description);
-            form.setFieldValue("tags", skillDraft.tags);
-            form.setFieldValue("content", skillDraft.content);
-            setInteractiveSkillName(skillDraft.name);
-            const existingSkill = allSkills.find(
-              (s) => s.name.toLowerCase() === skillDraft.name.toLowerCase()
-            );
-            setIsCreateMode(!existingSkill);
-            message.success(t("skillManagement.message.skillReadyForSave"));
-          } else {
-            // Fallback: read from temp file
-            try {
-              const { fetchSkillConfig, fetchSkillFileContent } = await import("@/services/agentConfigService");
-              const config = await fetchSkillConfig("simple-skill-creator");
-
-              if (config && config.temp_filename) {
-                const tempFilename = config.temp_filename as string;
-                const tempContent = await fetchSkillFileContent("simple-skill-creator", tempFilename);
-
-                if (tempContent) {
-                  const { extractSkillInfoFromContent } = await import("@/lib/skillFileUtils");
-                  const skillInfo = extractSkillInfoFromContent(tempContent);
-
-                  if (skillInfo && skillInfo.name) {
-                    form.setFieldValue("name", skillInfo.name);
-                    setInteractiveSkillName(skillInfo.name);
-                    const existingSkill = allSkills.find(
-                      (s) => s.name.toLowerCase() === skillInfo.name.toLowerCase()
-                    );
-                    setIsCreateMode(!existingSkill);
-                  }
-                  if (skillInfo && skillInfo.description) {
-                    form.setFieldValue("description", skillInfo.description);
-                  }
-                  if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
-                    form.setFieldValue("tags", skillInfo.tags);
-                  }
-                  // Use content without frontmatter
-                  if (skillInfo.contentWithoutFrontmatter) {
-                    form.setFieldValue("content", skillInfo.contentWithoutFrontmatter);
-                  }
-                }
+          onThinkingUpdate: (step, desc) => {
+            setThinkingStep(step);
+            setThinkingDescription(desc || THINKING_STEPS_ZH.find((s) => s.step === step)?.description || "");
+          },
+          onThinkingVisible: (visible) => {
+            setIsThinkingVisible(visible);
+          },
+          onStepCount: (step) => {
+            setThinkingStep(step);
+            setThinkingDescription(THINKING_STEPS_ZH.find((s) => s.step === step)?.description || "生成技能内容中 ...");
+          },
+          onFormContent: (content) => {
+            if (isStreamingCompleteRef.current) return;
+            setFormStreamingContent((prev) => prev + content);
+          },
+          onSummaryContent: (content) => {
+            setSummaryStreamingContent((prev) => prev + content);
+            setIsSummaryVisible(true);
+          },
+          onDone: (finalResult) => {
+            if (!isMountedRef.current) return;
+            setIsThinkingVisible(false);
+            setIsContentStreaming(false);
+            currentAssistantIdRef.current = "";
+            isStreamingCompleteRef.current = true;
+
+            const finalFormContent = finalResult.formContent;
+            if (finalFormContent) {
+              const skillInfo = extractSkillInfoFromContent(finalFormContent);
+
+              if (skillInfo && skillInfo.name) {
+                form.setFieldsValue({ name: skillInfo.name });
+                setInteractiveSkillName(skillInfo.name);
+                const existingSkill = allSkills.find(
+                  (s) => s.name.toLowerCase() === skillInfo.name?.toLowerCase()
+                );
+                setIsCreateMode(!existingSkill);
+              }
+              if (skillInfo && skillInfo.description) {
+                form.setFieldsValue({ description: skillInfo.description });
+              }
+              if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
+                form.setFieldsValue({ tags: skillInfo.tags });
               }
-            } catch (error) {
-              log.warn("Failed to load temp file content:", error);
+              if (skillInfo && skillInfo.contentWithoutFrontmatter) {
+                form.setFieldsValue({ content: skillInfo.contentWithoutFrontmatter });
+                setFormStreamingContent(skillInfo.contentWithoutFrontmatter);
+              }
+              message.success(t("skillManagement.message.skillReadyForSave"));
             }
-          }
-        },
-        "zh"
+          },
+          onError: (errorMsg) => {
+            log.error("Interactive skill creation error:", errorMsg);
+            message.error(t("skillManagement.message.chatError"));
+            setChatMessages((prev) => prev.filter((m) => m.id !== assistantId));
+            setIsContentStreaming(false);
+            currentAssistantIdRef.current = "";
+          },
+        }
       );
     } catch (error) {
       log.error("Interactive skill creation error:", error);
       message.error(t("skillManagement.message.chatError"));
       setChatMessages((prev) => prev.filter((m) => m.id !== assistantId));
+      setIsContentStreaming(false);
     } finally {
       setIsChatLoading(false);
     }
   };
 
-  // Handle chat clear
+  // Handle chat clear - reset all form fields
   const handleChatClear = async () => {
-    const { clearChatAndTempFile } = await import("@/services/skillService");
     await clearChatAndTempFile();
     setChatMessages([]);
+    form.resetFields(["name", "description", "source", "tags", "content"]);
+    setInteractiveSkillName("");
+    setFormStreamingContent("");
+    setThinkingStreamingContent("");
+    setSummaryStreamingContent("");
+    setIsSummaryVisible(false);
   };
 
   // Scroll to bottom of chat when new messages arrive
@@ -468,14 +479,15 @@ export default function SkillBuildModal({
     }
   }, [chatMessages]);
 
-  // Import extractSkillGenerationResult
-  const extractSkillGenerationResult = (content: string): string => {
-    const skillTagIndex = content.indexOf("</SKILL>");
-    if (skillTagIndex !== -1) {
-      return content.substring(skillTagIndex + 8).trim();
+  // Scroll to bottom of content textarea when streaming content updates
+  useEffect(() => {
+    if (formStreamingContent) {
+      const textarea = document.getElementById(contentTextAreaId.current);
+      if (textarea) {
+        textarea.scrollTop = textarea.scrollHeight;
+      }
     }
-    return content;
-  };
+  }, [formStreamingContent]);
 
   const renderInteractiveTab = () => {
     return (
@@ -523,25 +535,21 @@ export default function SkillBuildModal({
                       : "bg-gray-100 text-gray-800"
                   }`}
                 >
-                  {msg.role === "assistant" && isThinkingVisible && msg.content === "" ? (
-                    <div className="min-w-[200px]">
-                      <Progress
-                        percent={thinkingStep * 20}
-                        status="active"
-                        strokeColor="#52c41a"
-                        railColor="#e8e8e8"
-                      />
+                  {msg.role === "assistant" && isThinkingVisible && !isSummaryVisible ? (
+                    <div className="min-w-[200px] flex flex-col items-center">
+                      <Loader2 size={24} className="animate-spin text-blue-500" />
                       {thinkingDescription && (
-                        <span className="text-xs text-gray-500 mt-1 block">
+                        <span className="text-xs text-gray-500 mt-2">
                           {thinkingDescription}
                         </span>
                       )}
                     </div>
                   ) : msg.role === "assistant" ? (
-                    <div className="markdown-body">
-                      <ReactMarkdown>
-                        {extractSkillGenerationResult(msg.content)}
-                      </ReactMarkdown>
+                    <div className="markdown-content">
+                      <MarkdownRenderer
+                        content={isSummaryVisible ? summaryStreamingContent : msg.content}
+                        className="text-sm"
+                      />
                     </div>
                   ) : (
                     <div className="whitespace-pre-wrap">{msg.content}</div>
@@ -667,8 +675,16 @@ export default function SkillBuildModal({
               label={t("skillManagement.form.content")}
             >
               <TextArea
+                id={contentTextAreaId.current}
                 rows={6}
                 placeholder={t("skillManagement.form.contentPlaceholder")}
+                value={formStreamingContent}
+                onChange={(e) => {
+                  if (isContentStreaming) return;
+                  form.setFieldValue("content", e.target.value);
+                  setFormStreamingContent(e.target.value);
+                }}
+                disabled={isContentStreaming}
               />
             </Form.Item>
           </Form>
@@ -834,19 +850,17 @@ export default function SkillBuildModal({
     );
   };
 
-  // TODO: [FEATURE] Re-enable interactive skill creation tab
-  // See comment above for re-enablement criteria
   const tabItems = [
-    // {
-    //   key: "interactive",
-    //   label: (
-    //     <Flex gap={6} align="center">
-    //       <MessagesSquare size={14} />
-    //       <span>{t("skillManagement.tabs.interactive")}</span>
-    //     </Flex>
-    //   ),
-    //   children: renderInteractiveTab(),
-    // },
+    {
+      key: "interactive",
+      label: (
+        <Flex gap={6} align="center">
+          <MessagesSquare size={14} />
+          <span>{t("skillManagement.tabs.interactive")}</span>
+        </Flex>
+      ),
+      children: renderInteractiveTab(),
+    },
     {
       key: "upload",
       label: (
diff --git a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
index b458e6948..d09a06039 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
@@ -50,6 +50,44 @@ const TOOLS_REQUIRING_KB_SELECTION = [
   "idata_search",
 ];
 
+const TOOLS_SUPPORTING_RERANK = [
+  "knowledge_base_search",
+  "dify_search",
+  "datamate_search",
+];
+
+function withRerankParams(params: ToolParam[], toolName?: string): ToolParam[] {
+  if (!toolName || !TOOLS_SUPPORTING_RERANK.includes(toolName)) return params;
+
+  const hasRerank = params.some((p) => p.name === "rerank");
+  const hasRerankModelName = params.some((p) => p.name === "rerank_model_name");
+  if (hasRerank && hasRerankModelName) return params;
+
+  const next = [...params];
+
+  if (!hasRerank) {
+    next.push({
+      name: "rerank",
+      type: "boolean",
+      required: false,
+      value: false,
+      description: "Whether to enable reranking for search results",
+    });
+  }
+
+  if (!hasRerankModelName) {
+    next.push({
+      name: "rerank_model_name",
+      type: "string",
+      required: false,
+      value: "",
+      description: "The name of the rerank model to use",
+    });
+  }
+
+  return next;
+}
+
 export default function ToolConfigModal({
   isOpen,
   onCancel,
@@ -478,15 +516,16 @@ export default function ToolConfigModal({
     // If server_url already has a saved value, use it
     if (serverUrlParam?.value) {
       // Initialize form with saved values (including server_url)
-      setCurrentParams(initialParams);
+      const paramsWithRerank = withRerankParams(initialParams, tool.name);
+      setCurrentParams(paramsWithRerank);
       const formValues: Record<string, any> = {};
-      initialParams.forEach((param, index) => {
+      paramsWithRerank.forEach((param, index) => {
         formValues[`param_${index}`] = param.value;
       });
       form.setFieldsValue(formValues);
 
       // Parse initial index_names/dataset_ids value for knowledge base selection
-      const kbParam = initialParams.find(
+      const kbParam = paramsWithRerank.find(
         (p) => p.name === "index_names" || p.name === "dataset_ids"
       );
       if (kbParam?.value) {
@@ -521,18 +560,20 @@ export default function ToolConfigModal({
         return param;
       });
 
-      setCurrentParams(updatedParams);
+      const paramsWithRerank = withRerankParams(updatedParams, tool.name);
+      setCurrentParams(paramsWithRerank);
 
       const formValues: Record<string, any> = {};
-      updatedParams.forEach((param, index) => {
+      paramsWithRerank.forEach((param, index) => {
         formValues[`param_${index}`] = param.value;
       });
       form.setFieldsValue(formValues);
     } else {
       // Either no default available OR user has modified the URL, initialize with initialParams
-      setCurrentParams(initialParams);
+      const paramsWithRerank = withRerankParams(initialParams, tool.name);
+      setCurrentParams(paramsWithRerank);
       const formValues: Record<string, any> = {};
-      initialParams.forEach((param, index) => {
+      paramsWithRerank.forEach((param, index) => {
         formValues[`param_${index}`] = param.value;
       });
       form.setFieldsValue(formValues);
@@ -607,10 +648,11 @@ export default function ToolConfigModal({
       return param;
     });
 
-    setCurrentParams(updatedParams);
+    const paramsWithRerank = withRerankParams(updatedParams, tool.name);
+    setCurrentParams(paramsWithRerank);
 
     const formValues: Record<string, any> = {};
-    updatedParams.forEach((param, index) => {
+    paramsWithRerank.forEach((param, index) => {
       formValues[`param_${index}`] = param.value;
     });
     form.setFieldsValue(formValues);
@@ -632,9 +674,10 @@ export default function ToolConfigModal({
     }
 
     // Initialize form values
-    setCurrentParams(initialParams);
+    const paramsWithRerank = withRerankParams(initialParams, tool?.name);
+    setCurrentParams(paramsWithRerank);
     const formValues: Record<string, any> = {};
-    initialParams.forEach((param, index) => {
+    paramsWithRerank.forEach((param, index) => {
       formValues[`param_${index}`] = param.value;
     });
     form.setFieldsValue(formValues);
@@ -1176,6 +1219,36 @@ export default function ToolConfigModal({
     // Determine if this parameter should be rendered as a select dropdown
     const isSelectType = options && options.length > 0;
 
+    // Special handling for rerank_model_name parameter - show model selector
+    if (param.name === "rerank_model_name") {
+      // First try to get the list of available rerank models from config
+      const rerankConfig = configData?.models?.rerank;
+      const hasRerankModel = rerankConfig?.modelName;
+
+      if (hasRerankModel) {
+        // If rerank model is configured, show it as an option
+        const modelOptions = [{ value: rerankConfig.modelName, label: rerankConfig.displayName || rerankConfig.modelName }];
+        return (
+          <Select
+            placeholder={t("toolConfig.input.string.placeholder", {
+              name: param.description,
+            })}
+            options={modelOptions}
+            allowClear
+          />
+        );
+      }
+      // If no rerank model configured, show text input for manual entry
+      return (
+        <Input.TextArea
+          placeholder={t("toolConfig.input.string.placeholder", {
+            name: param.description,
+          })}
+          autoSize={{ minRows: 1, maxRows: 2 }}
+        />
+      );
+    }
+
     // Special handling for iData knowledge_space_id parameter
     const isIdataKnowledgeSpaceId =
       toolKbType === "idata_search" && param.name === "knowledge_space_id";
@@ -1269,6 +1342,14 @@ export default function ToolConfigModal({
     return inputComponent;
   };
 
+  const isRerankEnabled = useMemo(() => {
+    const rerankIndex = currentParams.findIndex((p) => p.name === "rerank");
+    if (rerankIndex < 0) return false;
+    const fieldName = `param_${rerankIndex}`;
+    const value = form.getFieldValue(fieldName);
+    return Boolean(value);
+  }, [currentParams, form, formValues]);
+
   if (!tool) return null;
 
   return (
@@ -1374,6 +1455,9 @@ export default function ToolConfigModal({
             >
               <div className="pr-2 mt-3">
                 {currentParams.map((param, index) => {
+                  if (param.name === "rerank_model_name" && !isRerankEnabled) {
+                    return null;
+                  }
                   const fieldName = `param_${index}`;
                   const rules: any[] = [];
 
@@ -1537,6 +1621,28 @@ export default function ToolConfigModal({
                 tool={tool}
                 onClose={handleCloseTestPanel}
                 configParams={currentParams}
+                toolRequiresKbSelection={toolRequiresKbSelection}
+                knowledgeBases={knowledgeBases}
+                kbLoading={kbLoading}
+                selectedKbIds={selectedKbIds}
+                selectedKbDisplayNames={selectedKbDisplayNames}
+                onOpenKbSelector={(paramIndex) => openKbSelector(paramIndex === -1 ? 0 : paramIndex)}
+                onKbSelectionChange={(ids, displayNames) => {
+                  setSelectedKbIds(ids);
+                  setSelectedKbDisplayNames(displayNames);
+                }}
+                onRemoveKb={(index, paramIndex) => {
+                  if (paramIndex === -1) {
+                    // Called from test panel - remove from selectedKbIds
+                    const newIds = selectedKbIds.filter((_, i) => i !== index);
+                    const newDisplayNames = selectedKbDisplayNames.filter((_, i) => i !== index);
+                    setSelectedKbIds(newIds);
+                    setSelectedKbDisplayNames(newDisplayNames);
+                  } else {
+                    // Called from config panel
+                    removeKbFromSelection(index, paramIndex);
+                  }
+                }}
               />
             )}
           </div>
diff --git a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolTestPanel.tsx b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolTestPanel.tsx
index 7eb56b995..f2bcc7f9e 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolTestPanel.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolTestPanel.tsx
@@ -2,10 +2,12 @@
 
 import { useState, useEffect, useRef } from "react";
 import { useTranslation } from "react-i18next";
-import { Input, Button, Card, Typography, Tooltip, Modal, Form } from "antd";
+import { Input, Button, Card, Typography, Tooltip, Modal, Form, Tag, Skeleton } from "antd";
 import { Settings, PenLine, X } from "lucide-react";
+import { CloseOutlined } from "@ant-design/icons";
 
 import { Tool, ToolParam } from "@/types/agentConfig";
+import { KnowledgeBase } from "@/types/knowledgeBase";
 import {
   validateTool,
   parseToolInputs,
@@ -26,6 +28,22 @@ export interface ToolTestPanelProps {
   configParams: ToolParam[];
   /** Callback when panel is closed */
   onClose: () => void;
+  /** Whether the tool requires knowledge base selection */
+  toolRequiresKbSelection?: boolean;
+  /** Knowledge bases for selection */
+  knowledgeBases?: KnowledgeBase[];
+  /** Whether knowledge bases are loading */
+  kbLoading?: boolean;
+  /** Callback to open knowledge base selector modal */
+  onOpenKbSelector?: (paramIndex: number) => void;
+  /** Selected knowledge base IDs for the index_names parameter */
+  selectedKbIds?: string[];
+  /** Selected knowledge base display names */
+  selectedKbDisplayNames?: string[];
+  /** Callback when knowledge base selection changes */
+  onKbSelectionChange?: (ids: string[], displayNames: string[]) => void;
+  /** Callback to remove a knowledge base from selection */
+  onRemoveKb?: (index: number, paramIndex: number) => void;
 }
 
 export default function ToolTestPanel({
@@ -33,10 +51,23 @@ export default function ToolTestPanel({
   tool,
   configParams,
   onClose,
+  toolRequiresKbSelection = false,
+  knowledgeBases = [],
+  kbLoading = false,
+  onOpenKbSelector,
+  selectedKbIds = [],
+  selectedKbDisplayNames = [],
+  onKbSelectionChange,
+  onRemoveKb,
 }: ToolTestPanelProps) {
   const { t } = useTranslation("common");
   const [form] = Form.useForm();
 
+  // Track if form has been initialized (to avoid resetting user input)
+  const formInitializedRef = useRef<boolean>(false);
+  // Track the last known tool to detect tool changes
+  const lastToolRef = useRef<string>("");
+
   // Tool test related state
   const [testExecuting, setTestExecuting] = useState<boolean>(false);
   const [testResult, setTestResult] = useState<string>("");
@@ -46,6 +77,13 @@ export default function ToolTestPanel({
   const [manualJsonInput, setManualJsonInput] = useState<string>("");
   const [isParseSuccessful, setIsParseSuccessful] = useState<boolean>(false);
 
+  // Reset form initialization flag when modal is closed or tool changes
+  useEffect(() => {
+    if (!visible) {
+      formInitializedRef.current = false;
+    }
+  }, [visible]);
+
   // Initialize test panel when opened
   useEffect(() => {
     if (!visible || !tool) {
@@ -58,6 +96,22 @@ export default function ToolTestPanel({
       setManualJsonInput("");
       setIsParseSuccessful(false);
       form.resetFields();
+      formInitializedRef.current = false;
+      return;
+    }
+
+    // Detect if tool has changed
+    const currentToolName = tool.origin_name || tool.name || "";
+    const toolChanged = lastToolRef.current !== currentToolName;
+
+    // Only re-initialize if the tool has changed, not just selectedKbIds
+    if (toolChanged) {
+      lastToolRef.current = currentToolName;
+      formInitializedRef.current = false;
+    }
+
+    // Skip if form is already initialized and tool hasn't changed
+    if (formInitializedRef.current && !toolChanged) {
       return;
     }
 
@@ -77,7 +131,14 @@ export default function ToolTestPanel({
         Object.entries(parsedInputs).forEach(([paramName, paramInfo]) => {
           const paramType = paramInfo?.type || DEFAULT_TYPE;
 
-          if (
+          // Check if this is the index_names parameter and KB selection is enabled
+          const isIndexNamesParam = paramName === "index_names" && toolRequiresKbSelection;
+
+          if (isIndexNamesParam && selectedKbIds.length > 0) {
+            // Use the selected KB IDs from configParams as default
+            parameterValues[paramName] = selectedKbIds;
+            formValues[`param_${paramName}`] = selectedKbIds;
+          } else if (
             paramInfo &&
             typeof paramInfo === "object" &&
             paramInfo.default != null
@@ -114,12 +175,15 @@ export default function ToolTestPanel({
         setIsManualInputMode(false);
         // Set manual input to current parsed values as default
         setManualJsonInput(JSON.stringify(parameterValues, null, 2));
+        // Mark form as initialized
+        formInitializedRef.current = true;
       } else {
         // Parsing returned empty object, treat as failed
         setParsedInputs({});
         setParameterValues({});
         setIsManualInputMode(true);
         setManualJsonInput("{}");
+        formInitializedRef.current = true;
       }
     } catch (error) {
       log.error("Parameter parsing error:", error);
@@ -129,8 +193,45 @@ export default function ToolTestPanel({
       // When parsing fails, automatically switch to manual input mode
       setIsManualInputMode(true);
       setManualJsonInput("{}");
+      formInitializedRef.current = true;
+    }
+  }, [tool, toolRequiresKbSelection, visible, form]);
+
+  // Sync KB selection with form values when selectedKbIds changes (but don't reset other fields)
+  useEffect(() => {
+    if (!toolRequiresKbSelection) return;
+
+    const fieldName = `param_index_names`;
+    const currentValue = form.getFieldValue(fieldName);
+
+    // Only update if the value is different
+    const idsMatch = Array.isArray(currentValue) &&
+      currentValue.length === selectedKbIds.length &&
+      currentValue.every((id: string, i: number) => id === selectedKbIds[i]);
+
+    if (!idsMatch) {
+      form.setFieldValue(fieldName, selectedKbIds);
+
+      // Also update the parameter values
+      if (selectedKbIds.length > 0) {
+        setParameterValues((prev) => ({
+          ...prev,
+          index_names: selectedKbIds,
+        }));
+        // Update manual JSON input while preserving other values
+        setManualJsonInput((prev) => {
+          try {
+            const parsed = JSON.parse(prev);
+            parsed.index_names = selectedKbIds;
+            return JSON.stringify(parsed, null, 2);
+          } catch {
+            // If JSON is invalid, keep the current value
+            return prev;
+          }
+        });
+      }
     }
-  }, [tool]);
+  }, [selectedKbIds, toolRequiresKbSelection, form]);
 
   // Close test panel
   const handleClose = () => {
@@ -141,6 +242,12 @@ export default function ToolTestPanel({
   const executeTest = async () => {
     if (!tool) return;
 
+    // Validate that knowledge base is selected when required
+    if (toolRequiresKbSelection && selectedKbIds.length === 0) {
+      setTestResult(`Test failed: Please select at least one knowledge base`);
+      return;
+    }
+
     setTestExecuting(true);
 
     try {
@@ -165,7 +272,16 @@ export default function ToolTestPanel({
           const paramInfo = parsedInputs[paramName];
           const paramType = paramInfo?.type || DEFAULT_TYPE;
 
-          if (value && value.trim() !== "") {
+          // Check if this is a KB selector parameter (index_names with KB selection enabled)
+          const isKbSelectorParam = paramName === "index_names" && toolRequiresKbSelection;
+
+          // Skip KB selector parameters - they will be handled separately
+          if (isKbSelectorParam) {
+            return;
+          }
+
+          // Handle string values
+          if (typeof value === "string" && value.trim() !== "") {
             // Convert value to correct type based on parameter type from inputs
             switch (paramType) {
               case "integer":
@@ -191,19 +307,39 @@ export default function ToolTestPanel({
               default:
                 toolParams[paramName] = value.trim();
             }
+          } else if (Array.isArray(value) && value.length > 0) {
+            // Handle array values (for non-KB selector array parameters)
+            toolParams[paramName] = value;
+          } else if (typeof value === "object" && value !== null) {
+            // Handle object values
+            toolParams[paramName] = value;
           }
         });
       }
 
+      // Override index_names with selectedKbIds if KB selection is enabled
+      if (toolRequiresKbSelection && selectedKbIds.length > 0) {
+        toolParams.index_names = selectedKbIds;
+      }
+
       // Prepare configuration parameters from currentParams
+      // Filter out index_names from configs when KB selection is enabled since it's passed via toolParams
       const configs = (configParams || []).reduce(
         (acc: Record<string, any>, param: ToolParam) => {
-          acc[param.name] = param.value;
+          // Skip index_names when KB selection is enabled (it's passed via toolParams)
+          if (toolRequiresKbSelection && (param.name === "index_names" || param.name === "dataset_ids")) {
+            return acc;
+          }
+          // Ensure top_k is always a number, not an array
+          if (param.name === "top_k" && Array.isArray(param.value)) {
+            acc[param.name] = param.value[0] || 3;
+          } else {
+            acc[param.name] = param.value;
+          }
           return acc;
         },
         {} as Record<string, any>
       );
-
       // Call validateTool with parameters
       const toolName = tool.origin_name || tool.name || "";
       const toolSource = tool.source || "";
@@ -277,7 +413,20 @@ export default function ToolTestPanel({
 
                       Object.keys(parameterValues).forEach((paramName) => {
                         const formValue = currentFormValues[`param_${paramName}`];
-                        if (formValue && formValue.trim() !== "") {
+
+                        // Check if this is a KB selector parameter
+                        const isKbSelectorParam = paramName === "index_names" && toolRequiresKbSelection;
+
+                        // Handle KB selector parameters - use selectedKbIds
+                        if (isKbSelectorParam) {
+                          if (selectedKbIds.length > 0) {
+                            currentParamsJson[paramName] = selectedKbIds;
+                          }
+                          return;
+                        }
+
+                        // Handle string values
+                        if (typeof formValue === "string" && formValue.trim() !== "") {
                           const paramInfo = parsedInputs[paramName];
                           const paramType = paramInfo?.type || DEFAULT_TYPE;
 
@@ -305,6 +454,12 @@ export default function ToolTestPanel({
                           } catch {
                             currentParamsJson[paramName] = formValue.trim();
                           }
+                        } else if (Array.isArray(formValue) && formValue.length > 0) {
+                          // Handle array values
+                          currentParamsJson[paramName] = formValue;
+                        } else if (typeof formValue === "object" && formValue !== null) {
+                          // Handle object values
+                          currentParamsJson[paramName] = formValue;
                         }
                       });
                       setManualJsonInput(
@@ -321,25 +476,35 @@ export default function ToolTestPanel({
                           const paramInfo = parsedInputs[paramName];
                           const paramType = paramInfo?.type || DEFAULT_TYPE;
 
+                          // Check if this is a KB selector parameter
+                          const isKbSelectorParam = paramName === "index_names" && toolRequiresKbSelection;
+
                           if (manualValue !== undefined) {
-                            // Convert to string for display based on parameter type
-                            switch (paramType) {
-                              case "boolean":
-                                formValues[`param_${paramName}`] = manualValue
-                                  ? "true"
-                                  : "false";
-                                break;
-                              case "array":
-                              case "object":
-                                formValues[`param_${paramName}`] =
-                                  JSON.stringify(manualValue, null, 2);
-                                break;
-                              default:
-                                formValues[`param_${paramName}`] =
-                                  String(manualValue);
+                            // KB selector parameters should keep their array form
+                            if (isKbSelectorParam) {
+                              formValues[`param_${paramName}`] = Array.isArray(manualValue)
+                                ? manualValue
+                                : [];
+                            } else {
+                              // Convert to string for display based on parameter type
+                              switch (paramType) {
+                                case "boolean":
+                                  formValues[`param_${paramName}`] = manualValue
+                                    ? "true"
+                                    : "false";
+                                  break;
+                                case "array":
+                                case "object":
+                                  formValues[`param_${paramName}`] =
+                                    JSON.stringify(manualValue, null, 2);
+                                  break;
+                                default:
+                                  formValues[`param_${paramName}`] =
+                                    String(manualValue);
+                              }
                             }
                           } else {
-                            formValues[`param_${paramName}`] = "";
+                            formValues[`param_${paramName}`] = isKbSelectorParam ? [] : "";
                           }
                         });
                         form.setFieldsValue(formValues);
@@ -398,6 +563,19 @@ export default function ToolTestPanel({
                       const fieldName = `param_${paramName}`;
                       const rules: any[] = [];
 
+                      // Check if this is the index_names parameter and KB selection is enabled
+                      const isKbSelectorParam = paramName === "index_names" && toolRequiresKbSelection;
+
+                      // Get display names based on selected KB IDs and knowledge bases
+                      let displayNames: string[] = [];
+                      if (isKbSelectorParam && selectedKbIds.length > 0 && knowledgeBases.length > 0) {
+                        displayNames = selectedKbIds.map((id) => {
+                          const cleanId = id.trim();
+                          const kb = knowledgeBases.find((k) => k.id === cleanId);
+                          return kb?.display_name || kb?.name || cleanId;
+                        });
+                      }
+
                       // Add type-specific validation rules
                       switch (paramInfo?.type || DEFAULT_TYPE) {
                         case "array":
@@ -450,6 +628,83 @@ export default function ToolTestPanel({
                           break;
                       }
 
+                      // Render knowledge base selector for index_names parameter
+                      if (isKbSelectorParam) {
+                        return (
+                          <Form.Item
+                            key={paramName}
+                            label={
+                              <span
+                                style={{ width: "100%" }}
+                                title={paramName}
+                              >
+                                {paramName}
+                              </span>
+                            }
+                            name={fieldName}
+                            rules={rules}
+                            tooltip={{
+                              title: getLocalizedDescription(description, description_zh),
+                              placement: "topLeft",
+                              styles: { root: { maxWidth: 400 } },
+                            }}
+                          >
+                            <div>
+                              <div
+                                className="cursor-pointer bg-white border rounded px-3 py-2 transition-colors border-gray-300 hover:border-blue-400"
+                                onClick={() => onOpenKbSelector?.(-1)} // -1 indicates this is from test panel
+                                style={{
+                                  width: "100%",
+                                  minHeight: "32px",
+                                  display: "flex",
+                                  flexWrap: "wrap",
+                                  alignItems: "center",
+                                  gap: "4px",
+                                }}
+                                title={displayNames.join(", ")}
+                              >
+                                {kbLoading && knowledgeBases.length === 0 ? (
+                                  <div className="flex items-center gap-2 w-full">
+                                    <Skeleton.Input active size="small" style={{ width: "60%" }} />
+                                  </div>
+                                ) : displayNames.length > 0 ? (
+                                  displayNames.map((name, i) => (
+                                    <Tag
+                                      key={selectedKbIds[i]}
+                                      closeIcon={
+                                        <span className="ant-tag-close-icon">
+                                          <CloseOutlined style={{ fontSize: "10px" }} />
+                                        </span>
+                                      }
+                                      onClose={(e) => {
+                                        e.stopPropagation();
+                                        onRemoveKb?.(i, -1); // -1 indicates this is from test panel
+                                      }}
+                                      style={{
+                                        marginRight: 0,
+                                        display: "inline-flex",
+                                        alignItems: "center",
+                                        lineHeight: "20px",
+                                        padding: "0 8px",
+                                        fontSize: "13px",
+                                      }}
+                                    >
+                                      {name}
+                                    </Tag>
+                                  ))
+                                ) : (
+                                  <span className="text-gray-400 text-sm">
+                                    {t("toolConfig.input.knowledgeBaseSelector.placeholder", {
+                                      name: getLocalizedDescription(description, description_zh) || paramName,
+                                    })}
+                                  </span>
+                                )}
+                              </div>
+                            </div>
+                          </Form.Item>
+                        );
+                      }
+
                       return (
                         <Form.Item
                           key={paramName}
diff --git a/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx b/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
index 7e796a33e..4c26da19d 100644
--- a/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
+++ b/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
@@ -420,6 +420,9 @@ export const ModelAddDialog = ({
         isValidVectorDimension(form.vectorDimension)
       );
     }
+    if (form.type === MODEL_TYPES.RERANK) {
+      return form.name.trim() !== "" && form.url.trim() !== "";
+    }
     return (
       form.name.trim() !== "" &&
       form.url.trim() !== "" &&
@@ -476,7 +479,9 @@ export const ModelAddDialog = ({
           maxTokens:
             form.type === MODEL_TYPES.EMBEDDING
               ? parseInt(form.vectorDimension)
-              : parseInt(form.maxTokens),
+              : form.type === MODEL_TYPES.RERANK
+                ? 0
+                : parseInt(form.maxTokens),
           embeddingDim:
             form.type === MODEL_TYPES.EMBEDDING
               ? parseInt(form.vectorDimension)
@@ -659,9 +664,10 @@ export const ModelAddDialog = ({
       let maxTokensValue = parseInt(form.maxTokens);
       if (
         form.type === MODEL_TYPES.EMBEDDING ||
-        form.type === MODEL_TYPES.MULTI_EMBEDDING
+        form.type === MODEL_TYPES.MULTI_EMBEDDING ||
+        form.type === MODEL_TYPES.RERANK
       ) {
-        // For embedding models, use the vector dimension as maxTokens
+        // For embedding/rerank models, the backend does not rely on max_tokens in the same way as LLM.
         maxTokensValue = 0;
       }
 
@@ -778,6 +784,7 @@ export const ModelAddDialog = ({
   };
 
   const isEmbeddingModel = form.type === MODEL_TYPES.EMBEDDING;
+  const isRerankModel = form.type === MODEL_TYPES.RERANK;
 
   return (
     <Modal
@@ -859,7 +866,7 @@ export const ModelAddDialog = ({
               {t("model.type.embedding")}
             </Option>
             <Option value={MODEL_TYPES.VLM}>{t("model.type.vlm")}</Option>
-            <Option value={MODEL_TYPES.RERANK} disabled>
+            <Option value={MODEL_TYPES.RERANK}>
               {t("model.type.rerank")}
             </Option>
             <Option value={MODEL_TYPES.STT} disabled>
@@ -1022,7 +1029,7 @@ export const ModelAddDialog = ({
         )}
 
         {/* Max Tokens */}
-        {!isEmbeddingModel && !form.isBatchImport && (
+        {!isEmbeddingModel && !isRerankModel && !form.isBatchImport && (
           <div>
             <label
               htmlFor="maxTokens"
diff --git a/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx b/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
index ebd7097d8..eeddec04f 100644
--- a/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
+++ b/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
@@ -86,6 +86,7 @@ export const ModelEditDialog = ({
   const isEmbeddingModel =
     form.type === MODEL_TYPES.EMBEDDING ||
     form.type === MODEL_TYPES.MULTI_EMBEDDING;
+  const isRerankModel = form.type === MODEL_TYPES.RERANK;
 
   const isFormValid = () => {
     return form.name.trim() !== "" && form.url.trim() !== "";
@@ -138,6 +139,8 @@ export const ModelEditDialog = ({
           maxTokens:
             form.type === MODEL_TYPES.EMBEDDING
               ? parseInt(form.vectorDimension)
+              : form.type === MODEL_TYPES.RERANK
+                ? 0
               : parseInt(form.maxTokens),
           embeddingDim:
             form.type === MODEL_TYPES.EMBEDDING
@@ -179,7 +182,7 @@ export const ModelEditDialog = ({
       const modelType = form.type as ModelType;
       // Determine max tokens
       let maxTokensValue = parseInt(form.maxTokens);
-      if (isEmbeddingModel) maxTokensValue = 0;
+      if (isEmbeddingModel || isRerankModel) maxTokensValue = 0;
 
       // Use original displayName for lookup, pass new displayName in body if changed
       const originalDisplayName = model.displayName || model.name;
@@ -314,7 +317,7 @@ export const ModelEditDialog = ({
         </div>
 
         {/* maxTokens */}
-        {!isEmbeddingModel && (
+        {!isEmbeddingModel && !isRerankModel && (
           <div>
             <label className="block mb-1 text-sm font-medium text-gray-700">
               {t("model.dialog.label.maxTokens")}
diff --git a/frontend/app/[locale]/models/components/modelConfig.tsx b/frontend/app/[locale]/models/components/modelConfig.tsx
index 9a686352d..e20e74876 100644
--- a/frontend/app/[locale]/models/components/modelConfig.tsx
+++ b/frontend/app/[locale]/models/components/modelConfig.tsx
@@ -489,7 +489,7 @@ export const ModelConfigSection = forwardRef<
           if (category === "voice") {
             modelType =
               optionId === MODEL_TYPES.TTS ? MODEL_TYPES.TTS : MODEL_TYPES.STT;
-          } else if (category === MODEL_TYPES.RERANK) {
+          } else if (category === "reranker") {
             modelType = MODEL_TYPES.RERANK;
           } else if (category === "multimodal") {
             modelType = MODEL_TYPES.VLM;
@@ -651,7 +651,7 @@ export const ModelConfigSection = forwardRef<
     if (category === "voice") {
       modelType =
         option === MODEL_TYPES.TTS ? MODEL_TYPES.TTS : MODEL_TYPES.STT;
-    } else if (category === MODEL_TYPES.RERANK) {
+    } else if (category === "reranker") {
       modelType = MODEL_TYPES.RERANK;
     } else if (category === "multimodal") {
       modelType = MODEL_TYPES.VLM;
@@ -680,7 +680,7 @@ export const ModelConfigSection = forwardRef<
       configKey = "multiEmbedding";
     } else if (category === "multimodal") {
       configKey = MODEL_TYPES.VLM;
-    } else if (category === MODEL_TYPES.RERANK) {
+    } else if (category === "reranker") {
       configKey = MODEL_TYPES.RERANK;
     } else if (category === "voice" && option === "tts") {
       configKey = MODEL_TYPES.TTS;
@@ -985,7 +985,9 @@ export const ModelConfigSection = forwardRef<
                               : key === MODEL_TYPES.EMBEDDING &&
                                   option.id === MODEL_TYPES.MULTI_EMBEDDING
                                 ? MODEL_TYPES.MULTI_EMBEDDING
-                                : (key as ModelType)
+                                : key === "reranker"
+                                  ? MODEL_TYPES.RERANK
+                                  : (key as ModelType)
                         }
                         modelId={option.id}
                         modelTypeName={option.name}
diff --git a/frontend/lib/skillFileUtils.tsx b/frontend/lib/skillFileUtils.tsx
index 0b290cf35..8682b870b 100644
--- a/frontend/lib/skillFileUtils.tsx
+++ b/frontend/lib/skillFileUtils.tsx
@@ -22,13 +22,15 @@ const extractFrontmatter = (content: string): { name: string | null; description
   const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   const frontmatterMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
 
-  if (!frontmatterMatch) return { name: null, description: null };
+  if (!frontmatterMatch) {
+    return { name: null, description: null };
+  }
 
   const frontmatter = frontmatterMatch[1];
 
-  // Try yaml.load first
+  // Try yaml.load first with JSON schema (safest, no type coercion issues)
   try {
-    const parsed = yaml.load(frontmatter) as Record<string, unknown> | null;
+    const parsed = yaml.load(frontmatter, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown> | null;
 
     // Check if yaml.load returned a valid object with the required fields
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -42,7 +44,7 @@ const extractFrontmatter = (content: string): { name: string | null; description
         return { name, description };
       }
     }
-  } catch {
+  } catch (e) {
     // yaml.load failed, fall through to regex extraction
   }
 
@@ -53,7 +55,7 @@ const extractFrontmatter = (content: string): { name: string | null; description
 
 /**
  * Fallback regex-based extraction when yaml.load fails.
- * Handles simple YAML key: value pairs including multi-line values.
+ * Handles simple YAML key: value pairs including multi-line values and block scalars.
  */
 const extractFrontmatterByRegex = (frontmatter: string): { name: string | null; description: string | null } => {
   let name: string | null = null;
@@ -65,37 +67,55 @@ const extractFrontmatterByRegex = (frontmatter: string): { name: string | null;
     name = nameMatch[1].trim();
   }
 
-  // Extract description field - handles multi-line values with proper indentation
-  // Look for "description:" followed by content until next top-level key
+  // Extract description field - need to handle block scalars (">" and "|")
+  // The key insight: "description:" line may be followed by ">" on the same line,
+  // and then all indented lines are the value
+  const descStartMatch = frontmatter.match(/^description:\s*/m);
+  if (!descStartMatch) {
+    return { name, description };
+  }
+
+  // Find the line number where description starts
   const lines = frontmatter.split('\n');
-  let descLines: string[] = [];
-  let inDescription = false;
-
-  for (const line of lines) {
-    // Skip empty lines at start
-    if (!inDescription && line.match(/^description:\s*$/)) {
-      inDescription = true;
-      continue;
+  let descLineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^description:\s*/)) {
+      descLineIndex = i;
+      break;
     }
+  }
+
+  if (descLineIndex === -1) {
+    return { name, description };
+  }
 
-    if (inDescription) {
-      // Check if this line is a new top-level key (no leading whitespace)
-      if (line.match(/^[a-z_]+:/)) {
-        // End of description
+  const descStartLine = lines[descLineIndex];
+  const remainingLines = lines.slice(descLineIndex + 1);
+
+  // Check if description uses block scalar (">" or "|")
+  const hasBlockScalar = /^(description:\s*)>|^(description:\s*)\|/.test(descStartLine);
+
+  if (hasBlockScalar) {
+    // Block scalar: collect all lines that have at least one leading space
+    const contentLines: string[] = [];
+    for (const line of remainingLines) {
+      // Non-empty line without leading space ends the block
+      if (line.length > 0 && !line.startsWith(' ') && !line.startsWith('\t')) {
         break;
       }
-      // Collect description lines
-      descLines.push(line.replace(/^[ \t]+/, ''));
+      // Collect the line, removing the leading space (YAML block scalars use 1 space indent)
+      if (line.trim() !== '') {
+        contentLines.push(line.replace(/^ /, ''));
+      }
+    }
+    if (contentLines.length > 0) {
+      description = contentLines.join('\n').trim();
     }
-  }
-
-  if (descLines.length > 0) {
-    description = descLines.join(' ').trim();
   } else {
-    // Fallback: try single-line description
-    const singleLineDescMatch = frontmatter.match(/^description:\s*(.+?)\s*$/m);
-    if (singleLineDescMatch && singleLineDescMatch[1]) {
-      description = singleLineDescMatch[1].trim();
+    // Single-line value: capture everything after "description:"
+    const inlineMatch = descStartLine.match(/^description:\s*(.+?)\s*$/);
+    if (inlineMatch && inlineMatch[1]) {
+      description = inlineMatch[1].trim();
     }
   }
 
@@ -188,26 +208,67 @@ export const extractSkillInfoFromContent = (content: string): { name: string; de
 
   if (!content) return result;
 
-  const skillBlockMatch = content.match(/<SKILL>([\s\S]*?)<\/SKILL>/);
+  // Content may or may not have <SKILL> wrapper tags depending on source.
+  // Try to extract the block content first.
+  const skillBlockMatch = content.match(/<SKILL>([\s\S]*?)<\/SKILL>/i);
   const blockContent = skillBlockMatch ? skillBlockMatch[1] : content;
 
-  const frontmatterMatch = blockContent.match(/^---\n([\s\S]*?)\n---/);
-  if (frontmatterMatch) {
-    const frontmatter = frontmatterMatch[1];
-    const parsed = yaml.load(frontmatter) as Record<string, unknown>;
-    if (parsed && typeof parsed === "object") {
+  // Normalize line endings so regex patterns work with CRLF (Windows) input
+  const normalizedBlock = blockContent.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+
+  // Try to match the frontmatter block. The content may have a leading newline
+  // before the opening --- (e.g. "\n---\n..."), so we use indexOf-based approach
+  // for more reliable matching than regex with non-greedy quantifiers.
+  let frontmatter: string | null = null;
+  let frontmatterStart = -1;
+  let frontmatterEnd = -1;
+
+  // Find opening --- (must be at start of line: position 0 or after \n)
+  const firstDash = normalizedBlock.indexOf("---");
+  if (firstDash !== -1) {
+    const isAtLineStart = firstDash === 0 || normalizedBlock[firstDash - 1] === "\n";
+    if (isAtLineStart) {
+      frontmatterStart = firstDash;
+      // Find closing --- (must be on its own line, after opening)
+      const searchStart = frontmatterStart + 3;
+      // First try "\n---" format
+      let secondDash = normalizedBlock.indexOf("\n---", searchStart);
+      if (secondDash !== -1) {
+        frontmatterEnd = secondDash + 1; // Include the \n in the boundary
+      } else {
+        // Try to find "---" at line start
+        let i = searchStart;
+        while (i < normalizedBlock.length) {
+          const nextDash = normalizedBlock.indexOf("---", i);
+          if (nextDash === -1) break;
+          const isClosingDash = nextDash === 0 || normalizedBlock[nextDash - 1] === "\n";
+          if (isClosingDash) {
+            frontmatterEnd = nextDash;
+            break;
+          }
+          i = nextDash + 3;
+        }
+      }
+      if (frontmatterEnd !== -1) {
+        frontmatter = normalizedBlock.substring(frontmatterStart, frontmatterEnd + 3);
+      }
+    }
+  }
+
+  if (frontmatter) {
+    // Extract YAML content between the opening --- and closing ---
+    const yamlContent = frontmatter
+      .replace(/^---/, "")
+      .replace(/---$/, "")
+      .trim();
+    const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown> | null;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       result.name = typeof parsed.name === "string" ? parsed.name.trim() : "";
       result.description = typeof parsed.description === "string" ? parsed.description.trim() : "";
       result.tags = Array.isArray(parsed.tags) ? parsed.tags.filter((t): t is string => typeof t === "string") : [];
     }
-    // Extract content after frontmatter
-    const frontmatterEnd = blockContent.indexOf("---");
-    const secondDash = blockContent.indexOf("---", frontmatterEnd + 3);
-    if (secondDash !== -1) {
-      result.contentWithoutFrontmatter = blockContent.substring(secondDash + 3).trim();
-    } else {
-      result.contentWithoutFrontmatter = blockContent.substring(frontmatterEnd + 3).trim();
-    }
+    // Extract content after frontmatter (everything after the closing ---)
+    result.contentWithoutFrontmatter = normalizedBlock.substring(frontmatterEnd + 3).trim();
   } else {
     result.contentWithoutFrontmatter = blockContent;
   }
@@ -261,18 +322,6 @@ export const parseSkillDraft = (content: string): {
   return { name, description, tags, content: contentWithoutFrontmatter };
 };
 
-/**
- * Extract content after </SKILL> tag for display.
- * @param content The full content string
- * @returns Content after </SKILL> tag
- */
-export const extractSkillGenerationResult = (content: string): string => {
-  const skillTagIndex = content.indexOf("</SKILL>");
-  if (skillTagIndex !== -1) {
-    return content.substring(skillTagIndex + 8).trim();
-  }
-  return content;
-};
 
 // ========== Skill Detail Modal Methods ==========
 
diff --git a/frontend/server.js b/frontend/server.js
index 05f098402..06cbf7016 100644
--- a/frontend/server.js
+++ b/frontend/server.js
@@ -28,7 +28,7 @@ const RUNTIME_HTTP_BACKEND =
   process.env.RUNTIME_HTTP_BACKEND || "http://localhost:5014"; // runtime
 const MINIO_BACKEND = process.env.MINIO_ENDPOINT || "http://localhost:9010";
 const MARKET_BACKEND =
-  process.env.MARKET_BACKEND || "https://market.nexent.tech"; // market
+  process.env.MARKET_BACKEND || "http://60.204.251.153:8010"; // market
 const PORT = 3000;
 
 const proxy = createProxyServer();
diff --git a/frontend/services/api.ts b/frontend/services/api.ts
index ba7c3a230..1a0b55c71 100644
--- a/frontend/services/api.ts
+++ b/frontend/services/api.ts
@@ -237,6 +237,8 @@ export const API_ENDPOINTS = {
       `${API_BASE_URL}/skills/${skillName}/files/${filePath}`,
     instanceList: `${API_BASE_URL}/skills/instance/list`,
     instanceUpdate: `${API_BASE_URL}/skills/instance/update`,
+    createSimple: `${API_BASE_URL}/skills/create-simple`,
+    creatorCache: `${API_BASE_URL}/skills/creator/cache`,
   },
   memory: {
     // ---------------- Memory configuration ----------------
diff --git a/frontend/services/skillService.ts b/frontend/services/skillService.ts
index bad0651ce..fbd9902bd 100644
--- a/frontend/services/skillService.ts
+++ b/frontend/services/skillService.ts
@@ -1,23 +1,15 @@
 import { message } from "antd";
 import log from "@/lib/logger";
-import { conversationService } from "@/services/conversationService";
 import {
   createSkill,
   updateSkill,
   createSkillFromFile,
   searchSkillsByName as searchSkillsByNameApi,
-  fetchSkillConfig,
-  deleteSkillTempFile,
   fetchSkills,
 } from "@/services/agentConfigService";
-import {
-  extractSkillInfoFromContent,
-  parseSkillDraft,
-} from "@/lib/skillFileUtils";
 import {
   THINKING_STEPS_ZH,
-  THINKING_STEPS_EN,
-  type SkillDraftResult,
+  type CreateSimpleSkillRequest,
 } from "@/types/skill";
 
 // ========== Type Definitions ==========
@@ -78,7 +70,7 @@ export interface ThinkingStep {
  * Get thinking steps based on language
  */
 export const getThinkingSteps = (lang: string): ThinkingStep[] => {
-  return lang === "zh" ? THINKING_STEPS_ZH : THINKING_STEPS_EN;
+  return lang === "zh" ? THINKING_STEPS_ZH : THINKING_STEPS_ZH;
 };
 
 
@@ -150,20 +142,6 @@ export const processSkillStream = async (
   return finalAnswer;
 };
 
-/**
- * Delete temp file from skill creator directory
- */
-export const deleteSkillCreatorTempFile = async (): Promise<void> => {
-  try {
-    const config = await fetchSkillConfig("simple-skill-creator");
-    if (config && typeof config === "object" && config.temp_filename) {
-      await deleteSkillTempFile("simple-skill-creator", config.temp_filename as string);
-    }
-  } catch (error) {
-    log.warn("Failed to delete temp file:", error);
-  }
-};
-
 // ========== Skill Operation Functions ==========
 
 /**
@@ -244,7 +222,6 @@ export const submitSkillForm = async (
     }
 
     if (result.success) {
-      await deleteSkillCreatorTempFile();
       message.success(
         existingSkill
           ? t("skillManagement.message.updateSuccess")
@@ -304,113 +281,10 @@ export const submitSkillFromFile = async (
 };
 
 /**
- * Interactive skill creation via chat with agent
- */
-export const runInteractiveSkillCreation = async (
-  input: string,
-  history: { role: "user" | "assistant"; content: string }[],
-  skillCreatorAgentId: number,
-  onThinkingUpdate: (step: number, description: string) => void,
-  onThinkingVisible: (visible: boolean) => void,
-  onMessageUpdate: (messages: { id: string; role: "user" | "assistant"; content: string; timestamp: Date }[]) => void,
-  onLoadingChange: (loading: boolean) => void,
-  allSkills: SkillListItem[],
-  form: { setFieldValue: (name: string, value: unknown) => void },
-  t: (key: string) => string,
-  isMountedRef: React.MutableRefObject<boolean>
-): Promise<{ success: boolean; skillDraft: SkillDraftResult | null }> => {
-  try {
-    const reader = await conversationService.runAgent(
-      {
-        query: input,
-        conversation_id: 0,
-        history,
-        agent_id: skillCreatorAgentId,
-        is_debug: true,
-      },
-      undefined as unknown as AbortSignal
-    );
-
-    let finalAnswer = "";
-
-    await processSkillStream(
-      reader,
-      onThinkingUpdate,
-      onThinkingVisible,
-      (answer) => {
-        finalAnswer = answer;
-      },
-      "zh"
-    );
-
-    if (!isMountedRef.current) {
-      return { success: false, skillDraft: null };
-    }
-
-    const skillDraft = parseSkillDraft(finalAnswer);
-    if (skillDraft) {
-      form.setFieldValue("name", skillDraft.name);
-      form.setFieldValue("description", skillDraft.description);
-      form.setFieldValue("tags", skillDraft.tags);
-      form.setFieldValue("content", skillDraft.content);
-
-      message.success(t("skillManagement.message.skillReadyForSave"));
-      return { success: true, skillDraft };
-    } else {
-      // Fallback: read temp file if no skill draft parsed
-      if (!isMountedRef.current) {
-        return { success: false, skillDraft: null };
-      }
-
-      try {
-        const config = await fetchSkillConfig("simple-skill-creator");
-        if (config && config.temp_filename && isMountedRef.current) {
-          const { fetchSkillFileContent } = await import("@/services/agentConfigService");
-          const tempFilename = config.temp_filename as string;
-          const tempContent = await fetchSkillFileContent("simple-skill-creator", tempFilename);
-
-          if (tempContent && isMountedRef.current) {
-            const skillInfo = extractSkillInfoFromContent(tempContent);
-
-            if (skillInfo && skillInfo.name) {
-              form.setFieldValue("name", skillInfo.name);
-            }
-            if (skillInfo && skillInfo.description) {
-              form.setFieldValue("description", skillInfo.description);
-            }
-            if (skillInfo && skillInfo.tags && skillInfo.tags.length > 0) {
-              form.setFieldValue("tags", skillInfo.tags);
-            }
-            if (skillInfo.contentWithoutFrontmatter) {
-              form.setFieldValue("content", skillInfo.contentWithoutFrontmatter);
-            }
-          }
-        }
-      } catch (error) {
-        log.warn("Failed to load temp file content:", error);
-      }
-
-      return { success: false, skillDraft: null };
-    }
-  } catch (error) {
-    log.error("Interactive skill creation error:", error);
-    message.error(t("skillManagement.message.chatError"));
-    return { success: false, skillDraft: null };
-  }
-};
-
-/**
- * Clear chat and delete temp file
+ * Clear chat state (no backend call needed)
  */
 export const clearChatAndTempFile = async (): Promise<void> => {
-  try {
-    const config = await fetchSkillConfig("simple-skill-creator");
-    if (config && typeof config === "object" && config.temp_filename) {
-      await deleteSkillTempFile("simple-skill-creator", config.temp_filename as string);
-    }
-  } catch (error) {
-    log.warn("Failed to delete temp file on clear:", error);
-  }
+  // No backend call needed - just clear local state
 };
 
 /**
@@ -444,3 +318,363 @@ export const skillNameExists = (
 };
 
 export { updateSkill };
+
+/**
+ * Call the /skills/create-simple backend API to generate a skill.
+ */
+import { API_ENDPOINTS, fetchWithErrorHandling } from "@/services/api";
+
+export interface CreateSimpleSkillResponse {
+  skill_name: string;
+  skill_description: string;
+  tags: string[];
+  skill_content: string;
+}
+
+/**
+ * Interactive skill creation via backend API (SDK-backed).
+ */
+export const createSimpleSkill = async (
+  request: CreateSimpleSkillRequest
+): Promise<CreateSimpleSkillResponse> => {
+  const response = await fetchWithErrorHandling(API_ENDPOINTS.skills.createSimple, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  return response.json();
+};
+
+/**
+ * Parse streaming content with <SKILL> delimiters.
+ * Content inside <SKILL></SKILL> goes to form content.
+ * Content outside <SKILL></SKILL> that appears BEFORE the <SKILL> tag is ignored (preceding noise).
+ * Content outside that appears AFTER the </SKILL> tag is the summary.
+ */
+export interface SkillDelimiterParseResult {
+  formContent: string;
+  summaryContent: string;
+  newFormContent: string;
+  newSummaryContent: string;
+  summaryStarted: boolean;
+}
+
+/**
+ * Extract summary content from final_answer.
+ * final_answer contains the FULL response including <SKILL> block.
+ * The SKILL content was already streamed via skill_content events,
+ * so we only need the summary (content AFTER </SKILL>).
+ */
+function extractSummaryFromFinalAnswer(fullContent: string): string {
+  const SKILL_CLOSE = "</SKILL>";
+  const closeIndex = fullContent.indexOf(SKILL_CLOSE);
+  if (closeIndex === -1) {
+    return fullContent;
+  }
+  return fullContent.substring(closeIndex + SKILL_CLOSE.length).trim();
+}
+
+/**
+ * Initialize a skill delimiter parser state.
+ * Matches uppercase <SKILL></SKILL> XML delimiters from the backend.
+ */
+export function createSkillDelimiterParser(): {
+  update: (chunk: string) => SkillDelimiterParseResult;
+  getFullResult: () => SkillDelimiterParseResult;
+} {
+  let formContent = "";
+  let summaryContent = "";
+  let buffer = "";
+  let isInsideSkillTag = false;
+  let summaryStarted = false;
+  // Tracks potential partial </SKILL> prefix across chunks
+  let pendingClose = "";
+  const SKILL_OPEN = "<SKILL>";
+  const SKILL_CLOSE = "</SKILL>";
+  const CLOSE_LEN = SKILL_CLOSE.length; // 8
+
+  return {
+    update(chunk: string): SkillDelimiterParseResult {
+      buffer += chunk;
+      let newFormContent = "";
+      let newSummaryContent = "";
+
+      while (buffer.length > 0) {
+        if (isInsideSkillTag) {
+          // Check if pendingClose + buffer contains </SKILL>
+          const combined = pendingClose + buffer;
+          const closeIdx = combined.indexOf(SKILL_CLOSE);
+          if (closeIdx !== -1) {
+            // Found </SKILL>!
+            // Content before it (minus pendingClose) is safe to output as form content.
+            const content = combined.substring(0, closeIdx);
+            const safeContent = content.substring(pendingClose.length);
+            if (safeContent.length > 0) {
+              formContent += safeContent;
+              newFormContent += safeContent;
+            }
+            // Everything after </SKILL> is summary.
+            const afterClose = combined.substring(closeIdx + CLOSE_LEN);
+            if (afterClose.length > 0) {
+              summaryContent += afterClose;
+              newSummaryContent += afterClose;
+            }
+            buffer = "";
+            pendingClose = "";
+            isInsideSkillTag = false;
+            summaryStarted = true;
+            break;
+          }
+
+          // No full </SKILL> in combined. Decide what to save as pendingClose.
+          if (combined.length <= CLOSE_LEN - 1) {
+            // Too short to contain </SKILL>. Hold all as pending, output nothing.
+            pendingClose = combined;
+            buffer = "";
+            break;
+          }
+
+          // Buffer is long enough. Check if combined ends with potential partial </SKILL.
+          const lastPossible = combined.slice(-(CLOSE_LEN - 1)); // Last 7 chars
+          if (lastPossible.startsWith("</SK")) {
+            // Looks like partial </SKILL. Hold last 7 chars, output rest.
+            const safeLen = combined.length - (CLOSE_LEN - 1);
+            const safe = combined.substring(0, safeLen);
+            formContent += safe;
+            newFormContent += safe;
+            pendingClose = lastPossible;
+            buffer = "";
+            break;
+          }
+
+          // Does not look like partial </SKILL>. Output all as content.
+          formContent += combined;
+          newFormContent += combined;
+          buffer = "";
+          pendingClose = "";
+          break;
+        } else {
+          const openIdx = buffer.indexOf(SKILL_OPEN);
+          if (openIdx !== -1) {
+            buffer = buffer.substring(openIdx + SKILL_OPEN.length);
+            isInsideSkillTag = true;
+            pendingClose = "";
+          } else {
+            if (buffer.includes("<")) {
+              break;
+            } else {
+              buffer = "";
+              break;
+            }
+          }
+        }
+      }
+
+      return {
+        formContent,
+        summaryContent,
+        newFormContent,
+        newSummaryContent,
+        summaryStarted,
+      };
+    },
+
+    getFullResult(): SkillDelimiterParseResult {
+      if (isInsideSkillTag) {
+        // Any remaining buffer or pendingClose is form content
+        if (buffer.length > 0) {
+          formContent += buffer;
+        }
+        if (pendingClose.length > 0) {
+          formContent += pendingClose;
+        }
+      }
+      isInsideSkillTag = false;
+      return {
+        formContent,
+        summaryContent,
+        newFormContent: "",
+        newSummaryContent: "",
+        summaryStarted: true,
+      };
+    },
+  };
+}
+
+/**
+ * SSE event types for streaming skill creation
+ */
+export interface SkillCreationStreamEvent {
+  type: "step_count" | "final_answer" | "skill_content" | "skill_result" | "done" | "error";
+  content?: string;
+  skill_name?: string;
+  skill_description?: string;
+  tags?: string[];
+  message?: string;
+}
+
+/**
+ * Interactive skill creation via SSE stream with progress updates.
+ * Uses <SKILL></SKILL> delimiters to separate form content from summary.
+ */
+export const createSimpleSkillStream = async (
+  request: CreateSimpleSkillRequest,
+  callbacks: {
+    onStepCount: (step: number, description: string) => void;
+    onThinkingVisible: (visible: boolean) => void;
+    onThinkingUpdate: (step: number, description: string) => void;
+    onSkillContent?: (content: string) => void;
+    onSkillResult?: (result: { skill_name: string; skill_description: string; tags: string[] }) => void;
+    onFormContent?: (content: string) => void;
+    onSummaryContent?: (content: string) => void;
+    onDone: (finalResult: SkillDelimiterParseResult) => void;
+    onError: (message: string) => void;
+  }
+): Promise<SkillDelimiterParseResult> => {
+  const response = await fetch(API_ENDPOINTS.skills.createSimple, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    callbacks.onError(`HTTP error: ${response.status}`);
+    return { formContent: "", summaryContent: "", newFormContent: "", newSummaryContent: "", summaryStarted: false };
+  }
+
+  if (!response.body) {
+    callbacks.onError("No response body");
+    return { formContent: "", summaryContent: "", newFormContent: "", newSummaryContent: "", summaryStarted: false };
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const delimiterParser = createSkillDelimiterParser();
+  // Track pending stream promises so 'done' case can await them
+  const pendingStreamPromises: Promise<void>[] = [];
+
+  callbacks.onThinkingVisible(true);
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      // Strip any stray \r so the buffer uses only \n internally.
+      // This handles Windows CRLF line endings in the SSE stream.
+      const cleanChunk = decoder.decode(value, { stream: true }).replace(/\r/g, "");
+      buffer += cleanChunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+        const jsonStr = line.substring(5).trim();
+        if (!jsonStr) continue;
+
+        try {
+          const event: SkillCreationStreamEvent = JSON.parse(jsonStr);
+
+          switch (event.type) {
+            case "step_count": {
+              const stepMatch = String(event.content).match(/\d+/);
+              const stepNum = stepMatch ? parseInt(stepMatch[0], 10) : NaN;
+              if (!isNaN(stepNum)) {
+                callbacks.onThinkingUpdate(stepNum, "");
+                callbacks.onStepCount(stepNum, "");
+              }
+              break;
+            }
+            case "skill_content":
+              if (event.content) {
+                const parsed = delimiterParser.update(event.content);
+                // Only send to form when still inside <SKILL> tags (summaryStarted=false).
+                // Once summaryStarted=true, all content is summary text, not form content.
+                if (parsed.newFormContent && !parsed.summaryStarted && callbacks.onFormContent) {
+                  callbacks.onFormContent(parsed.newFormContent);
+                }
+                if (parsed.newSummaryContent && callbacks.onSummaryContent) {
+                  callbacks.onSummaryContent(parsed.newSummaryContent);
+                }
+                if (callbacks.onSkillContent) {
+                  callbacks.onSkillContent(event.content);
+                }
+              }
+              break;
+            case "final_answer":
+              if (event.content) {
+                // final_answer contains the FULL response including <SKILL> block.
+                // The SKILL content was already streamed via skill_content events.
+                // Only extract the summary (content after </SKILL>) from final_answer.
+                const summary = extractSummaryFromFinalAnswer(event.content);
+                if (summary && callbacks.onSummaryContent) {
+                  // Use async loop with setTimeout to allow React to render each chunk.
+                  // Without the delay, all state updates batch into one render.
+                  const CHUNK_SIZE = 3; // characters per chunk
+                  const CHUNK_DELAY = 15; // ms between chunks
+                  // Wrap streaming in a promise so we can await it before onDone
+                  const streamPromise = new Promise<void>((resolve) => {
+                    const streamChunk = (index: number): void => {
+                      if (index >= summary.length) {
+                        resolve();
+                        return;
+                      }
+                      const chunk = summary.substring(index, index + CHUNK_SIZE);
+                      callbacks.onSummaryContent!(chunk);
+                      setTimeout(() => streamChunk(index + CHUNK_SIZE), CHUNK_DELAY);
+                    };
+                    streamChunk(0);
+                  });
+                  // Store promise to be awaited in 'done' case
+                  pendingStreamPromises.push(streamPromise);
+                }
+              }
+              break;
+            case "skill_result":
+              if (callbacks.onSkillResult) {
+                callbacks.onSkillResult({
+                  skill_name: event.skill_name || "",
+                  skill_description: event.skill_description || "",
+                  tags: event.tags || [],
+                });
+              }
+              break;
+            case "done":
+              callbacks.onThinkingVisible(false);
+              {
+                const finalResult = delimiterParser.getFullResult();
+                // Await all pending stream promises before calling onDone
+                Promise.all(pendingStreamPromises)
+                  .then(() => {
+                    try {
+                      callbacks.onDone(finalResult);
+                    } catch {
+                      // Ignore callback errors
+                    }
+                  })
+                  .catch(() => {
+                    // Ignore promise errors
+                    try {
+                      callbacks.onDone(finalResult);
+                    } catch {
+                      // Ignore callback errors
+                    }
+                  });
+              }
+              break;
+            case "error":
+              callbacks.onThinkingVisible(false);
+              callbacks.onError(event.message || "Unknown error");
+              break;
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+    }
+  } finally {
+    callbacks.onThinkingVisible(false);
+  }
+  return delimiterParser.getFullResult();
+};
diff --git a/frontend/types/skill.ts b/frontend/types/skill.ts
index 8d3a14451..64b43c3c8 100644
--- a/frontend/types/skill.ts
+++ b/frontend/types/skill.ts
@@ -13,24 +13,16 @@ export const MAX_RECENT_SKILLS = 5;
  * Interactive skill creation steps (Chinese)
  */
 export const THINKING_STEPS_ZH = [
-  { step: 0, description: "等待大模型响应..." },
-  { step: 1, description: "加载内置技能提示词..." },
-  { step: 2, description: "加载技能配置..." },
-  { step: 3, description: "生成技能 SKILL.md ..." },
-  { step: 4, description: "保存中..." },
-  { step: 5, description: "已完成, 正在总结..." },
+  { step: 1, description: "生成技能内容中 ..." },
+  { step: 2, description: "总结中 ..." },
 ];
 
 /**
  * Interactive skill creation steps (English)
  */
 export const THINKING_STEPS_EN = [
-  { step: 0, description: "Waiting for model response..." },
-  { step: 1, description: "Loading built-in skills..." },
-  { step: 2, description: "Loading dynamic config..." },
-  { step: 3, description: "Generating skill SKILL.md ..." },
-  { step: 4, description: "Saving skill..." },
-  { step: 5, description: "Done, summarizing..." },
+  { step: 1, description: "Generating skill content..." },
+  { step: 2, description: "Summarizing..." },
 ];
 
 /**
@@ -61,6 +53,13 @@ export interface ChatMessage {
   timestamp: Date;
 }
 
+/**
+ * Result of parsing a skill draft from AI response
+ */
+export interface CreateSimpleSkillRequest {
+  user_request: string;
+}
+
 /**
  * Result of parsing a skill draft from AI response
  */
diff --git a/k8s/helm/nexent/charts/nexent-common/values.yaml b/k8s/helm/nexent/charts/nexent-common/values.yaml
index 2a2083aea..b8f253a47 100644
--- a/k8s/helm/nexent/charts/nexent-common/values.yaml
+++ b/k8s/helm/nexent/charts/nexent-common/values.yaml
@@ -41,7 +41,7 @@ config:
   skipProxy: "true"
   umask: "0022"
   isDeployedByKubernetes: "true"
-  marketBackend: "https://market.nexent.tech"
+  marketBackend: "http://60.204.251.153:8010"
   modelEngine:
     enabled: "false"
   voiceService:
diff --git a/k8s/helm/nexent/charts/nexent-web/values.yaml b/k8s/helm/nexent/charts/nexent-web/values.yaml
index 4f1acb205..74337791c 100644
--- a/k8s/helm/nexent/charts/nexent-web/values.yaml
+++ b/k8s/helm/nexent/charts/nexent-web/values.yaml
@@ -16,7 +16,7 @@ resources:
       cpu: 500m
 
 config:
-  marketBackend: "https://market.nexent.tech"
+  marketBackend: "http://60.204.251.153:8010"
   modelEngine:
     enabled: "false"
 
diff --git a/sdk/nexent/core/agents/agent_model.py b/sdk/nexent/core/agents/agent_model.py
index 4311f88fa..f7533f5b5 100644
--- a/sdk/nexent/core/agents/agent_model.py
+++ b/sdk/nexent/core/agents/agent_model.py
@@ -42,6 +42,7 @@ class AgentConfig(BaseModel):
     model_name: str = Field(description="Model alias from ModelConfig")
     provide_run_summary: Optional[bool] = Field(description="Whether to provide run summary to upper-level Agent", default=False)
     managed_agents: List[AgentConfig] = Field(description="Managed Agents", default=[])
+    instructions: Optional[str] = Field(description="Additional instructions to prepend to system prompt", default=None)
 
 
 class AgentHistory(BaseModel):
diff --git a/sdk/nexent/core/agents/nexent_agent.py b/sdk/nexent/core/agents/nexent_agent.py
index 68c0e2509..3878e05dd 100644
--- a/sdk/nexent/core/agents/nexent_agent.py
+++ b/sdk/nexent/core/agents/nexent_agent.py
@@ -73,7 +73,7 @@ def create_local_tool(self, tool_config: ToolConfig):
                 # These parameters have exclude=True and cannot be passed to __init__
                 # due to smolagents.tools.Tool wrapper restrictions
                 filtered_params = {k: v for k, v in params.items()
-                                   if k not in ["vdb_core", "embedding_model", "observer"]}
+                                   if k not in ["vdb_core", "embedding_model", "observer", "rerank_model"]}
                 # Create instance with only non-excluded parameters
                 tools_obj = tool_class(**filtered_params)
                 # Set excluded parameters directly as attributes after instantiation
@@ -83,9 +83,16 @@ def create_local_tool(self, tool_config: ToolConfig):
                     "vdb_core", None) if tool_config.metadata else None
                 tools_obj.embedding_model = tool_config.metadata.get(
                     "embedding_model", None) if tool_config.metadata else None
-            elif class_name == "DataMateSearchTool":
-                tools_obj = tool_class(**params)
+                tools_obj.rerank_model = tool_config.metadata.get(
+                    "rerank_model", None) if tool_config.metadata else None
+            elif class_name in ["DifySearchTool", "DataMateSearchTool"]:
+                # These parameters have exclude=True and cannot be passed to __init__
+                filtered_params = {k: v for k, v in params.items()
+                                   if k not in ["observer", "rerank_model"]}
+                tools_obj = tool_class(**filtered_params)
                 tools_obj.observer = self.observer
+                tools_obj.rerank_model = tool_config.metadata.get(
+                    "rerank_model", None) if tool_config.metadata else None
             elif class_name == "AnalyzeTextFileTool":
                 tools_obj = tool_class(observer=self.observer,
                                        llm_model=tool_config.metadata.get("llm_model", []),
@@ -232,6 +239,7 @@ def create_single_agent(self, agent_config: AgentConfig):
                 provide_run_summary=agent_config.provide_run_summary,
                 managed_agents=managed_agents_list,
                 additional_authorized_imports=["*"],
+                instructions=agent_config.instructions,
             )
             agent.stop_event = self.stop_event
 
diff --git a/sdk/nexent/core/models/rerank_model.py b/sdk/nexent/core/models/rerank_model.py
new file mode 100644
index 000000000..5332284f2
--- /dev/null
+++ b/sdk/nexent/core/models/rerank_model.py
@@ -0,0 +1,322 @@
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+import requests
+
+
+class BaseRerank(ABC):
+    """
+    Abstract base class for rerank models, defining methods that all rerank models should implement.
+    """
+
+    @abstractmethod
+    def __init__(
+        self,
+        model_name: str = None,
+        base_url: str = None,
+        api_key: str = None,
+        ssl_verify: bool = True,
+    ):
+        """
+        Initialize the rerank model.
+
+        Args:
+            model_name: Name of the rerank model
+            base_url: Base URL of the rerank API
+            api_key: API key for the rerank API
+            ssl_verify: Whether to verify SSL certificates for network requests
+        """
+        pass
+
+    @abstractmethod
+    def rerank(
+        self,
+        query: str,
+        documents: List[str],
+        top_n: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Rerank documents based on their relevance to the query.
+
+        Args:
+            query: The search query
+            documents: List of document texts to rerank
+            top_n: Number of top results to return (default: all documents)
+
+        Returns:
+            List of reranked results, each containing document index and relevance score
+        """
+        pass
+
+    @abstractmethod
+    async def connectivity_check(self, timeout: float = 5.0) -> bool:
+        """
+        Test the connectivity to the rerank API.
+
+        Args:
+            timeout: Timeout in seconds
+
+        Returns:
+            bool: Returns True if the connection is successful, False if it fails or times out
+        """
+        pass
+
+
+class OpenAICompatibleRerank(BaseRerank):
+    """
+    OpenAI-compatible rerank implementation.
+    Supports any API that follows the OpenAI reranking format.
+    """
+
+    def __init__(
+        self,
+        model_name: str,
+        base_url: str,
+        api_key: str,
+        ssl_verify: bool = True,
+    ):
+        """
+        Initialize OpenAICompatibleRerank with configuration.
+
+        Args:
+            model_name: Name of the rerank model
+            base_url: Base URL of the rerank API
+            api_key: API key for the rerank API
+            ssl_verify: Whether to verify SSL certificates for network requests
+        """
+        self.model = model_name
+        self.api_url = base_url
+        self.api_key = api_key
+        self.ssl_verify = ssl_verify
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+    def _prepare_request(self, query: str, documents: List[str], top_n: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Prepare the request data for the API.
+
+        Args:
+            query: The search query
+            documents: List of document texts to rerank
+            top_n: Number of top results to return
+
+        Returns:
+            Dict containing the request payload
+        """
+        # DashScope rerank API uses "input" and "parameters" wrapper for ALL models (qwen3-rerank, gte-rerank-v2, etc.)
+        if "dashscope" in self.api_url.lower():
+            return {
+                "model": self.model,
+                "input": {
+                    "query": query,
+                    "documents": documents,
+                },
+                "parameters": {
+                    "top_n": top_n or len(documents),
+                },
+            }
+        # OpenAI-compatible format
+        return {
+            "model": self.model,
+            "query": query,
+            "documents": documents,
+            "top_n": top_n or len(documents),
+        }
+
+    def _make_request(self, data: Dict[str, Any], timeout: Optional[float] = None) -> Dict[str, Any]:
+        """
+        Make the API request and return the response.
+
+        Args:
+            data: Request data
+            timeout: Timeout in seconds
+
+        Returns:
+            Dict containing the API response
+        """
+        response = requests.post(
+            self.api_url,
+            headers=self.headers,
+            json=data,
+            timeout=timeout,
+            verify=self.ssl_verify
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def rerank(
+        self,
+        query: str,
+        documents: List[str],
+        top_n: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Rerank documents based on their relevance to the query.
+
+        Args:
+            query: The search query
+            documents: List of document texts to rerank
+            top_n: Number of top results to return
+
+        Returns:
+            List of reranked results with index and relevance_score
+        """
+        if not documents:
+            return []
+
+        data = self._prepare_request(query, documents, top_n)
+
+        base_timeout = 30.0
+        attempts = 4
+        last_exception = None
+
+        for attempt_index in range(attempts):
+            current_timeout = base_timeout + attempt_index * 10.0
+            try:
+                response = self._make_request(data, timeout=current_timeout)
+                # DashScope returns results in {"output": {"results": [...]}}
+                # OpenAI-compatible returns {"results": [...]}
+                results = response.get("results") or response.get("output", {}).get("results", [])
+
+                reranked_results = []
+                for r in results:
+                    # DashScope returns document as {"text": "..."}, others return string directly
+                    doc = r.get("document")
+                    if isinstance(doc, dict):
+                        doc_text = doc.get("text")
+                    else:
+                        doc_text = doc
+                    reranked_results.append({
+                        "index": r.get("index"),
+                        "relevance_score": r.get("relevance_score"),
+                        "document": doc_text,
+                    })
+                return reranked_results
+
+            except requests.exceptions.Timeout as e:
+                logging.warning(
+                    f"Rerank API timed out in {current_timeout}s (attempt {attempt_index + 1}/{attempts})"
+                )
+                last_exception = e
+                if attempt_index == attempts - 1:
+                    logging.error("Rerank API timed out after all retries.")
+                    raise
+                continue
+
+            except requests.exceptions.RequestException as e:
+                logging.error(f"Rerank API request failed: {str(e)}")
+                raise
+
+        if last_exception:
+            raise last_exception
+        return []
+
+    async def rerank_async(
+        self,
+        query: str,
+        documents: List[str],
+        top_n: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Async version of rerank.
+
+        Args:
+            query: The search query
+            documents: List of document texts to rerank
+            top_n: Number of top results to return
+
+        Returns:
+            List of reranked results
+        """
+        return await asyncio.to_thread(self.rerank, query, documents, top_n)
+
+    async def connectivity_check(self, timeout: float = 5.0) -> bool:
+        """
+        Test the connectivity to the rerank API.
+
+        Args:
+            timeout: Timeout in seconds
+
+        Returns:
+            bool: True if connection is successful, False otherwise
+        """
+        try:
+            test_query = "test query"
+            test_documents = ["test document"]
+
+            await asyncio.to_thread(
+                self.rerank, test_query, test_documents, top_n=1
+            )
+            return True
+
+        except requests.exceptions.Timeout:
+            logging.error(f"Rerank API connection test timed out ({timeout} seconds)")
+            return False
+        except requests.exceptions.ConnectionError:
+            logging.error("Rerank API connection error, unable to establish connection")
+            return False
+        except Exception as e:
+            logging.error(f"Rerank API connectivity check failed: {str(e)}")
+            return False
+
+
+class JinaRerank(OpenAICompatibleRerank):
+    """
+    Jina AI rerank implementation.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.jina.ai/v1/rerank",
+        model_name: str = "jina-rerank-v2-base",
+        ssl_verify: bool = True,
+    ):
+        """
+        Initialize JinaRerank with configuration.
+
+        Args:
+            api_key: API key for Jina AI
+            base_url: Base URL of the Jina rerank API
+            model_name: Name of the Jina rerank model
+            ssl_verify: Whether to verify SSL certificates for network requests
+        """
+        super().__init__(
+            model_name=model_name,
+            base_url=base_url,
+            api_key=api_key,
+            ssl_verify=ssl_verify,
+        )
+
+
+class CohereRerank(OpenAICompatibleRerank):
+    """
+    Cohere rerank implementation.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.cohere.ai/v1/rerank",
+        model_name: str = "rerank-multilingual-v3.0",
+        ssl_verify: bool = True,
+    ):
+        """
+        Initialize CohereRerank with configuration.
+
+        Args:
+            api_key: API key for Cohere
+            base_url: Base URL of the Cohere rerank API
+            model_name: Name of the Cohere rerank model
+            ssl_verify: Whether to verify SSL certificates for network requests
+        """
+        super().__init__(
+            model_name=model_name,
+            base_url=base_url,
+            api_key=api_key,
+            ssl_verify=ssl_verify,
+        )
diff --git a/sdk/nexent/core/tools/datamate_search_tool.py b/sdk/nexent/core/tools/datamate_search_tool.py
index 626cbbca4..51931907b 100644
--- a/sdk/nexent/core/tools/datamate_search_tool.py
+++ b/sdk/nexent/core/tools/datamate_search_tool.py
@@ -7,7 +7,9 @@
 from urllib.parse import urlparse
 
 from ...vector_database import DataMateCore
+from ..models.rerank_model import BaseRerank
 from ..utils.observer import MessageObserver, ProcessType
+from ..utils.constants import RERANK_OVERSEARCH_MULTIPLIER
 from ..utils.tools_common_message import SearchResultTextMessage, ToolCategory, ToolSign
 
 # Get logger instance
@@ -84,6 +86,16 @@ def __init__(
             description="Default maximum number of search results to return", default=3),
         threshold: float = Field(
             description="Default similarity threshold for search results", default=0.2),
+        rerank: bool = Field(
+            description="Whether to enable reranking for search results",
+            default=False,
+        ),
+        rerank_model_name: str = Field(
+            description="The name of the rerank model to use",
+            default="",
+        ),
+        rerank_model: BaseRerank = Field(
+            description="The rerank model to use", default=None, exclude=True),
         kb_page: int = Field(
             description="Page index when listing knowledge bases from DataMate", default=1),
         kb_page_size: int = Field(
@@ -117,6 +129,9 @@ def __init__(
         self.index_names = [] if index_names is None else index_names
         self.top_k = top_k
         self.threshold = threshold
+        self.rerank = rerank
+        self.rerank_model_name = rerank_model_name
+        self.rerank_model = rerank_model
 
         # Determine SSL verification setting
         if verify_ssl is None:
@@ -214,13 +229,20 @@ def forward(
             if len(knowledge_base_ids) == 0:
                 return json.dumps("No knowledge base selected. No relevant information found.", ensure_ascii=False)
 
+            # Compute effective top_k for initial search:
+            # When rerank is enabled, retrieve more candidates to allow rerank to select the best ones.
+            effective_top_k = (
+                self.top_k * RERANK_OVERSEARCH_MULTIPLIER
+                if self.rerank else self.top_k
+            )
+
             # Step 2: Retrieve knowledge base content using DataMateCore hybrid search
             kb_search_results = []
             for knowledge_base_id in knowledge_base_ids:
                 kb_search = self.datamate_core.hybrid_search(
                     query_text=query,
                     index_names=[knowledge_base_id],
-                    top_k=self.top_k,
+                    top_k=effective_top_k,
                     weight_accurate=self.threshold,
                 )
                 if not kb_search:
@@ -228,6 +250,48 @@ def forward(
                         "No results found! Try a less restrictive/shorter query.")
                 kb_search_results.extend(kb_search)
 
+            # Apply reranking if enabled
+            if self.rerank and self.rerank_model and kb_search_results:
+                try:
+                    documents = []
+                    for r in kb_search_results:
+                        entity = r.get("entity", {}) or {}
+                        documents.append(entity.get("text", "") or "")
+
+                    reranked_results = self.rerank_model.rerank(
+                        query=query,
+                        documents=documents,
+                        top_n=len(documents),
+                    )
+
+                    if reranked_results:
+                        original_results_map = {
+                            i: kb_search_results[i] for i in range(len(kb_search_results))
+                        }
+                        reordered = []
+                        for reranked_item in reranked_results[: self.top_k]:
+                            orig_idx = reranked_item.get("index")
+                            if orig_idx is None or orig_idx not in original_results_map:
+                                continue
+                            result = original_results_map[orig_idx]
+                            entity = result.get("entity", {}) or {}
+                            entity["score"] = reranked_item.get(
+                                "relevance_score", entity.get("score", 0)
+                            )
+                            result["entity"] = entity
+                            reordered.append(result)
+
+                        if reordered:
+                            kb_search_results = reordered
+                            logger.info(
+                                f"Reranking applied: selected top {self.top_k} from "
+                                f"{len(documents)} candidates"
+                            )
+                except Exception as e:
+                    logger.warning(
+                        f"Reranking failed, using original results: {str(e)}"
+                    )
+
             # Format search results
             search_results_json = []  # Organize search results into a unified format
             search_results_return = []  # Format for input to the large model
diff --git a/sdk/nexent/core/tools/dify_search_tool.py b/sdk/nexent/core/tools/dify_search_tool.py
index 230b563a5..c1f94dc47 100644
--- a/sdk/nexent/core/tools/dify_search_tool.py
+++ b/sdk/nexent/core/tools/dify_search_tool.py
@@ -6,7 +6,9 @@
 from pydantic import Field
 from smolagents.tools import Tool
 
+from ..models.rerank_model import BaseRerank
 from ..utils.observer import MessageObserver, ProcessType
+from ..utils.constants import RERANK_OVERSEARCH_MULTIPLIER
 from ..utils.tools_common_message import SearchResultTextMessage, ToolCategory, ToolSign
 from ...utils.http_client_manager import http_client_manager
 
@@ -75,8 +77,18 @@ def __init__(
             description="Search method: keyword_search, semantic_search, full_text_search, hybrid_search",
             default="semantic_search",
         ),
+        rerank: bool = Field(
+            description="Whether to enable reranking for search results",
+            default=False,
+        ),
+        rerank_model_name: str = Field(
+            description="The name of the rerank model to use",
+            default="",
+        ),
         observer: MessageObserver = Field(
             description="Message observer", default=None, exclude=True),
+        rerank_model: BaseRerank = Field(
+            description="The rerank model to use", default=None, exclude=True),
     ):
         """Initialize the DifySearchTool.
 
@@ -123,6 +135,9 @@ def __init__(
         self.top_k = top_k
         self.search_method = search_method
         self.observer = observer
+        self.rerank = rerank
+        self.rerank_model_name = rerank_model_name
+        self.rerank_model = rerank_model
 
         # Cache HTTP client for reuse (uses shared HttpClientManager internally)
         self._http_client = http_client_manager.get_sync_client(
@@ -151,9 +166,17 @@ def forward(
         search_top_k = self.top_k
         search_method = self.search_method
 
+        # Compute effective top_k for initial search:
+        # When rerank is enabled, retrieve more candidates to allow rerank to select the best ones.
+        effective_top_k = (
+            search_top_k * RERANK_OVERSEARCH_MULTIPLIER
+            if self.rerank else search_top_k
+        )
+
         # Log the search parameters
         logger.info(
-            f"DifySearchTool called with query: '{query}', top_k: {search_top_k}, search_method: '{search_method}'"
+            f"DifySearchTool called with query: '{query}', top_k: {search_top_k}, "
+            f"effective_top_k: {effective_top_k}, search_method: '{search_method}'"
         )
 
         # Perform searches across all datasets
@@ -166,7 +189,7 @@ def forward(
             all_search_results = []
             for dataset_id in self.dataset_ids:
                 search_results_data = self._search_dify_knowledge_base(
-                    query, search_top_k, search_method, dataset_id)
+                    query, effective_top_k, search_method, dataset_id)
                 search_results = search_results_data.get("records", [])
                 # Add dataset_id to each result for URL generation
                 for result in search_results:
@@ -177,6 +200,46 @@ def forward(
                 raise Exception(
                     "No results found! Try a less restrictive/shorter query.")
 
+            # Apply reranking if enabled
+            if self.rerank and self.rerank_model and all_search_results:
+                try:
+                    documents = []
+                    for r in all_search_results:
+                        segment = r.get("segment", {}) or {}
+                        documents.append(segment.get("content", "") or "")
+
+                    reranked_results = self.rerank_model.rerank(
+                        query=query,
+                        documents=documents,
+                        top_n=len(documents),
+                    )
+
+                    if reranked_results:
+                        original_results_map = {
+                            i: all_search_results[i] for i in range(len(all_search_results))
+                        }
+                        reordered = []
+                        for reranked_item in reranked_results[: search_top_k]:
+                            orig_idx = reranked_item.get("index")
+                            if orig_idx is None or orig_idx not in original_results_map:
+                                continue
+                            result = original_results_map[orig_idx]
+                            result["score"] = reranked_item.get(
+                                "relevance_score", result.get("score", 0)
+                            )
+                            reordered.append(result)
+
+                        if reordered:
+                            all_search_results = reordered
+                            logger.info(
+                                f"Reranking applied: selected top {search_top_k} from "
+                                f"{len(documents)} candidates"
+                            )
+                except Exception as e:
+                    logger.warning(
+                        f"Reranking failed, using original results: {str(e)}"
+                    )
+
             # Collect all document info for batch URL fetching
             document_dataset_pairs = []
             for result in all_search_results:
diff --git a/sdk/nexent/core/tools/knowledge_base_search_tool.py b/sdk/nexent/core/tools/knowledge_base_search_tool.py
index c6e76f834..a8863caaf 100644
--- a/sdk/nexent/core/tools/knowledge_base_search_tool.py
+++ b/sdk/nexent/core/tools/knowledge_base_search_tool.py
@@ -1,13 +1,15 @@
 import json
 import logging
-from typing import List
+from typing import List, Optional
 
 from pydantic import Field
 from smolagents.tools import Tool
-
+from pydantic.fields import FieldInfo
 from ...vector_database.base import VectorDatabaseCore
 from ..models.embedding_model import BaseEmbedding
+from ..models.rerank_model import BaseRerank
 from ..utils.observer import MessageObserver, ProcessType
+from ..utils.constants import RERANK_OVERSEARCH_MULTIPLIER
 from ..utils.tools_common_message import SearchResultTextMessage, ToolCategory, ToolSign
 
 
@@ -38,7 +40,8 @@ class KnowledgeBaseSearchTool(Tool):
         "index_names": {
             "type": "array",
             "description": "The list of index names to search",
-            "description_zh": "要索引的知识库"
+            "description_zh": "要索引的知识库",
+            "nullable": True
         },
     }
 
@@ -69,10 +72,18 @@ def __init__(
             description="the search mode, optional values: hybrid, accurate, semantic",
             default="hybrid",
         ),
+        rerank: bool = Field(
+            description="Whether to enable reranking for search results",
+            default=False),
+        rerank_model_name: str = Field(
+            description="The name of the rerank model to use",
+            default=""),
         observer: MessageObserver = Field(
             description="Message observer", default=None, exclude=True),
         embedding_model: BaseEmbedding = Field(
             description="The embedding model to use", default=None, exclude=True),
+        rerank_model: BaseRerank = Field(
+            description="The rerank model to use", default=None, exclude=True),
         vdb_core: VectorDatabaseCore = Field(
             description="Vector database client", default=None, exclude=True),
     ):
@@ -92,15 +103,18 @@ def __init__(
         self.index_names = [] if index_names is None else index_names
         self.search_mode = search_mode
         self.embedding_model = embedding_model
+        self.rerank = rerank
+        self.rerank_model_name = rerank_model_name
+        self.rerank_model = rerank_model
 
         self.record_ops = 1  # To record serial number
         self.running_prompt_zh = "知识库检索中..."
         self.running_prompt_en = "Searching the knowledge base..."
 
 
-    def forward(self, query: str, index_names: List[str]) -> str:
+    def forward(self, query: str, index_names: Optional[List[str]] = None) -> str:
         # Parse index_names from string (always required)
-        search_index_names = index_names
+        search_index_names = index_names if index_names is not None else self.index_names
 
         # Use the instance search_mode
         search_mode = self.search_mode
@@ -118,18 +132,30 @@ def forward(self, query: str, index_names: List[str]) -> str:
             f"KnowledgeBaseSearchTool called with query: '{query}', search_mode: '{search_mode}', index_names: {search_index_names}"
         )
 
+        # Compute effective top_k for initial search:
+        # When rerank is enabled, retrieve more candidates to allow rerank to select the best ones.
+        # Note: smolagents Tool may not expand Field defaults, so use getattr with FieldInfo fallback.
+        effective_top_k = self.top_k
+        is_rerank = self.rerank
+        if isinstance(effective_top_k, FieldInfo):
+            effective_top_k = effective_top_k.default
+        if isinstance(is_rerank, FieldInfo):
+            is_rerank = is_rerank.default
+        if is_rerank:
+            effective_top_k = effective_top_k * RERANK_OVERSEARCH_MULTIPLIER
+
         if len(search_index_names) == 0:
             return json.dumps("No knowledge base selected. No relevant information found.", ensure_ascii=False)
 
         if search_mode == "hybrid":
             kb_search_data = self.search_hybrid(
-                query=query, index_names=search_index_names)
+                query=query, index_names=search_index_names, top_k=effective_top_k)
         elif search_mode == "accurate":
             kb_search_data = self.search_accurate(
-                query=query, index_names=search_index_names)
+                query=query, index_names=search_index_names, top_k=effective_top_k)
         elif search_mode == "semantic":
             kb_search_data = self.search_semantic(
-                query=query, index_names=search_index_names)
+                query=query, index_names=search_index_names, top_k=effective_top_k)
         else:
             raise Exception(
                 f"Invalid search mode: {search_mode}, only support: hybrid, accurate, semantic")
@@ -140,6 +166,40 @@ def forward(self, query: str, index_names: List[str]) -> str:
             raise Exception(
                 "No results found! Try a less restrictive/shorter query.")
 
+        # Apply reranking if enabled
+        if self.rerank and self.rerank_model and kb_search_results:
+            try:
+                # Extract document contents for reranking
+                documents = [
+                    result.get("content", "") for result in kb_search_results
+                ]
+                # Perform reranking on all retrieved candidates
+                reranked_results = self.rerank_model.rerank(
+                    query=query,
+                    documents=documents,
+                    top_n=len(documents)
+                )
+                # Reorder and trim to top_k after reranking
+                if reranked_results:
+                    original_results_map = {
+                        i: kb_search_results[i] for i in range(len(kb_search_results))
+                    }
+                    kb_search_results = []
+                    for reranked_item in reranked_results[: self.top_k]:
+                        orig_idx = reranked_item.get("index")
+                        if orig_idx is not None and orig_idx in original_results_map:
+                            result = original_results_map[orig_idx]
+                            result["score"] = reranked_item.get(
+                                "relevance_score", result.get("score", 0)
+                            )
+                            kb_search_results.append(result)
+                    logger.info(
+                        f"Reranking applied: selected top {self.top_k} from "
+                        f"{len(documents)} candidates"
+                    )
+            except Exception as e:
+                logger.warning(f"Reranking failed, using original results: {str(e)}")
+
         search_results_json = []  # Organize search results into a unified format
         search_results_return = []  # Format for input to the large model
         for index, single_search_result in enumerate(kb_search_results):
@@ -177,10 +237,10 @@ def forward(self, query: str, index_names: List[str]) -> str:
                 "", ProcessType.SEARCH_CONTENT, search_results_data)
         return json.dumps(search_results_return, ensure_ascii=False)
 
-    def search_hybrid(self, query, index_names):
+    def search_hybrid(self, query, index_names, top_k):
         try:
             results = self.vdb_core.hybrid_search(
-                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=self.top_k
+                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=top_k
             )
 
             # Format results
@@ -199,10 +259,10 @@ def search_hybrid(self, query, index_names):
         except Exception as e:
             raise Exception(f"Error during semantic search: {str(e)}")
 
-    def search_accurate(self, query, index_names):
+    def search_accurate(self, query, index_names, top_k):
         try:
             results = self.vdb_core.accurate_search(
-                index_names=index_names, query_text=query, top_k=self.top_k)
+                index_names=index_names, query_text=query, top_k=top_k)
 
             # Format results
             formatted_results = []
@@ -220,10 +280,10 @@ def search_accurate(self, query, index_names):
         except Exception as e:
             raise Exception(detail=f"Error during accurate search: {str(e)}")
 
-    def search_semantic(self, query, index_names):
+    def search_semantic(self, query, index_names, top_k):
         try:
             results = self.vdb_core.semantic_search(
-                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=self.top_k
+                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=top_k
             )
 
             # Format results
diff --git a/sdk/nexent/core/tools/read_skill_config_tool.py b/sdk/nexent/core/tools/read_skill_config_tool.py
index 85e84a7e3..5f535bdc3 100644
--- a/sdk/nexent/core/tools/read_skill_config_tool.py
+++ b/sdk/nexent/core/tools/read_skill_config_tool.py
@@ -36,7 +36,7 @@ def execute(self, skill_name: str) -> str:
         """Read the config.yaml file from a skill directory.
 
         Args:
-            skill_name: Name of the skill (e.g., "simple-skill-creator")
+            skill_name: Name of the skill (e.g., "skill-creator")
 
         Returns:
             JSON-serialized dict of the config file, or an error message.
@@ -109,14 +109,14 @@ def read_skill_config(skill_name: str) -> str:
     needed for skill creation workflows.
 
     Args:
-        skill_name: Name of the skill whose config.yaml to read (e.g., "simple-skill-creator")
+        skill_name: Name of the skill whose config.yaml to read (e.g., "skill-creator")
 
     Returns:
         JSON string containing the parsed config.yaml contents as a dictionary.
 
     Examples:
-        # Read the config for simple-skill-creator to get temp_skill path
-        read_skill_config("simple-skill-creator")
+        # Read the config for skill-creator to get temp_skill path
+        read_skill_config("skill-creator")
         # Returns: {"path": {"temp_skill": "/mnt/nexent/skills/tmp/"}}
     """
     tool_instance = get_read_skill_config_tool()
diff --git a/sdk/nexent/core/tools/read_skill_md_tool.py b/sdk/nexent/core/tools/read_skill_md_tool.py
index a70a37699..858bfb5e9 100644
--- a/sdk/nexent/core/tools/read_skill_md_tool.py
+++ b/sdk/nexent/core/tools/read_skill_md_tool.py
@@ -94,9 +94,11 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
         """Read skill markdown files.
 
         Args:
-            skill_name: Name of the skill
-            *additional_files: Optional additional files to read. If empty, reads SKILL.md.
-                If non-empty, only reads specified files (SKILL.md is NOT read by default
+            skill_name: Name of the skill. If empty, reads directly from local_skills_dir.
+            *additional_files: Optional additional files to read. If skill_name is empty,
+                this is treated as the file path directly. If skill_name is non-empty:
+                - If empty, reads SKILL.md by default.
+                - If non-empty, only reads specified files (SKILL.md is NOT read by default
                 unless explicitly included in the list).
 
         Returns:
@@ -104,6 +106,11 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
         """
         try:
             manager = self._get_skill_manager()
+
+            # If skill_name is empty, read directly from local_skills_dir
+            if not skill_name:
+                return self._read_direct_file(additional_files)
+
             skill = manager.load_skill(skill_name)
 
             if not skill:
@@ -138,6 +145,39 @@ def execute(self, skill_name: str, *additional_files: str) -> str:
             logger.error(f"Failed to read skill markdown: {e}")
             return f"Error reading skill: {str(e)}"
 
+    def _read_direct_file(self, path_parts: tuple) -> str:
+        """Read a file directly from local_skills_dir.
+
+        Args:
+            path_parts: Tuple of path components. If empty, reads SKILL.md from root.
+
+        Returns:
+            File content or error message
+        """
+        if not self.local_skills_dir:
+            return "[Error] local_skills_dir is not configured"
+
+        if not path_parts:
+            # No path specified, try to read SKILL.md from root
+            file_path = "SKILL.md"
+        else:
+            file_path = "/".join(path_parts)
+
+        full_path = os.path.join(self.local_skills_dir, file_path)
+        if not os.path.exists(full_path):
+            return f"File not found: {file_path}"
+
+        try:
+            with open(full_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            # Strip frontmatter if it's a markdown file
+            if full_path.endswith('.md'):
+                content = self._strip_frontmatter(content)
+            return content
+        except Exception as e:
+            logger.error(f"Failed to read file {full_path}: {e}")
+            return f"[Error] Failed to read '{file_path}': {e}"
+
 
 # Global instance for tool execution
 _skill_md_tool = None
@@ -170,15 +210,18 @@ def read_skill_md(skill_name: str, additional_files: Optional[list[str]] = None)
     Reads skill files from the skill root directory. Behavior depends on whether
     additional_files is provided:
 
-    - If additional_files is empty/not provided: reads SKILL.md by default
-    - If additional_files is provided: only reads the specified files (SKILL.md is NOT
-      included by default unless explicitly listed in additional_files)
+    - If skill_name is empty: reads directly from local_skills_dir root.
+      additional_files is treated as the file path. If empty, reads SKILL.md from root.
+    - If skill_name is non-empty and additional_files is empty: reads SKILL.md by default
+    - If skill_name is non-empty and additional_files is provided: only reads the specified
+      files (SKILL.md is NOT included by default unless explicitly listed)
 
     Use this tool to load the execution guide for a skill when you need to understand
     how to handle a specific task that matches the skill's purpose.
 
     Args:
-        skill_name: Name of the skill (e.g., "code-reviewer")
+        skill_name: Name of the skill (e.g., "code-reviewer"). If empty, reads directly
+            from local_skills_dir root.
         additional_files: Optional list of specific files to read. When provided, only
             reads these files (SKILL.md is not automatically included). Examples:
             - ["examples.md"] - reads only examples.md
@@ -195,6 +238,10 @@ def read_skill_md(skill_name: str, additional_files: Optional[list[str]] = None)
         # Only reads specified files (SKILL.md NOT included by default)
         read_skill_md("code-reviewer", ["examples.md"])
         read_skill_md("code-reviewer", ["SKILL.md", "examples.md"])
+
+        # Read directly from local_skills_dir (skill_name is empty)
+        read_skill_md("")  # reads SKILL.md from root
+        read_skill_md("", ["my-file.txt"])  # reads my-file.txt from root
     """
     tool_instance = get_read_skill_md_tool()
     files = additional_files or []
diff --git a/sdk/nexent/core/tools/write_skill_file_tool.py b/sdk/nexent/core/tools/write_skill_file_tool.py
index 71861fe9c..0ba54c080 100644
--- a/sdk/nexent/core/tools/write_skill_file_tool.py
+++ b/sdk/nexent/core/tools/write_skill_file_tool.py
@@ -1,7 +1,7 @@
 """Skill file writing tool."""
 import logging
 import os
-from typing import Any, Dict, Optional
+from typing import Optional
 from smolagents import tool
 
 logger = logging.getLogger(__name__)
@@ -52,7 +52,8 @@ def execute(
         """Write a file to a skill directory in local storage.
 
         Args:
-            skill_name: Name of the skill (e.g., "code-reviewer")
+            skill_name: Name of the skill (e.g., "code-reviewer").
+                If empty, writes directly to local_skills_dir.
             file_path: Relative path within the skill directory. Use forward slashes.
                 Examples: "SKILL.md", "scripts/analyze.py", "examples.md"
             content: File content to write
@@ -60,8 +61,6 @@ def execute(
         Returns:
             Success or error message
         """
-        if not skill_name:
-            return "[Error] skill_name is required"
         if not file_path:
             return "[Error] file_path is required"
 
@@ -70,6 +69,10 @@ def execute(
             pass
         normalized_path = normalized_path.lstrip("/")
 
+        # If skill_name is empty, write directly to local_skills_dir
+        if not skill_name:
+            return self._write_direct_file(normalized_path, content)
+
         try:
             manager = self._get_skill_manager()
         except Exception as e:
@@ -84,6 +87,29 @@ def execute(
             logger.error(f"Failed to write skill file: {e}")
             return f"[Error] Failed to write file: {type(e).__name__}: {str(e)}"
 
+    def _write_direct_file(self, relative_path: str, content: str) -> str:
+        """Write a file directly to local_skills_dir.
+
+        Args:
+            relative_path: Path relative to local_skills_dir
+            content: File content
+
+        Returns:
+            Success or error message
+        """
+        if not self.local_skills_dir:
+            return "[Error] local_skills_dir is not configured"
+
+        file_path = os.path.join(self.local_skills_dir, *relative_path.split("/"))
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return f"Successfully wrote '{relative_path}' to local_skills_dir"
+        except Exception as e:
+            return f"[Error] Failed to write '{relative_path}': {e}"
+
     def _write_skill_md(self, manager, skill_name: str, content: str) -> str:
         """Write SKILL.md using SkillManager.save_skill().
 
@@ -179,7 +205,8 @@ def write_skill_file(skill_name: str, file_path: str, content: str) -> str:
     agent's local_skills_dir configuration.
 
     Args:
-        skill_name: Name of the skill (e.g., "code-reviewer", "my-new-skill")
+        skill_name: Name of the skill (e.g., "code-reviewer", "my-new-skill").
+            If empty, writes directly to local_skills_dir.
         file_path: Relative path within the skill directory. Use forward slashes.
             - "SKILL.md" for the main skill file
             - "scripts/analyze.py" for Python scripts
@@ -199,6 +226,9 @@ def write_skill_file(skill_name: str, file_path: str, content: str) -> str:
 
         # Write supporting documentation
         write_skill_file("code-reviewer", "examples.md", "# Examples\\n...")
+
+        # Write directly to local_skills_dir (when skill_name is empty)
+        write_skill_file("", "my-file.txt", "file content")
     """
     tool_instance = get_write_skill_file_tool()
     return tool_instance.execute(skill_name, file_path, content)
diff --git a/sdk/nexent/core/utils/constants.py b/sdk/nexent/core/utils/constants.py
index ff297b2ca..6c6e63b78 100644
--- a/sdk/nexent/core/utils/constants.py
+++ b/sdk/nexent/core/utils/constants.py
@@ -1,3 +1,5 @@
 THINK_TAG_PATTERN = r"(?:<think>)?.*?</think>"
+RERANK_OVERSEARCH_MULTIPLIER = 10 #5
+
 # Pattern to match "思考：" or "思考:" followed by content until two newlines
 THINK_PREFIX_PATTERN = r"思考[：:].*?\n\n"
diff --git a/sdk/nexent/core/utils/prompt_template_utils.py b/sdk/nexent/core/utils/prompt_template_utils.py
index abf694549..ad06e9119 100644
--- a/sdk/nexent/core/utils/prompt_template_utils.py
+++ b/sdk/nexent/core/utils/prompt_template_utils.py
@@ -37,8 +37,6 @@ def get_prompt_template(template_type: str, language: str = LANGUAGE["ZH"], **kw
     Returns:
         dict: Loaded prompt template
     """
-    logger.info(
-        f"Getting prompt template for type: {template_type}, language: {language}, kwargs: {kwargs}")
 
     if template_type not in template_paths:
         raise ValueError(f"Unsupported template type: {template_type}")
diff --git a/sdk/nexent/skills/skill_loader.py b/sdk/nexent/skills/skill_loader.py
index b6aa5f6a0..734b83c24 100644
--- a/sdk/nexent/skills/skill_loader.py
+++ b/sdk/nexent/skills/skill_loader.py
@@ -40,13 +40,18 @@ def parse(cls, content: str, source_path: str = "") -> Dict[str, Any]:
         if not frontmatter:
             raise ValueError("SKILL.md must have YAML frontmatter")
 
-        # Fix YAML parsing to handle special characters in values
-        # Wrap unquoted values that may contain colons
-        frontmatter = cls._fix_yaml_frontmatter(frontmatter)
-
-        meta = yaml.safe_load(frontmatter)
+        # Try to parse with yaml.safe_load first
+        meta = None
+        try:
+            # Fix YAML parsing to handle special characters in values
+            frontmatter = cls._fix_yaml_frontmatter(frontmatter)
+            meta = yaml.safe_load(frontmatter)
+        except yaml.YAMLError as e:
+            logger.warning(f"YAML parse error, falling back to regex extraction: {e}")
+
+        # If yaml.safe_load failed or returned invalid result, use regex fallback
         if not isinstance(meta, dict):
-            raise ValueError("Invalid YAML frontmatter")
+            meta = cls._extract_frontmatter_by_regex(frontmatter)
 
         if "name" not in meta:
             raise ValueError("Skill must have 'name' field")
@@ -82,6 +87,12 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
                 fixed_lines.append(line)
                 continue
 
+            # Skip indented lines - these are content of multi-line values (block scalars)
+            # They should NOT be modified as they're part of block scalar values
+            if line.startswith(' ') or line.startswith('\t'):
+                fixed_lines.append(line)
+                continue
+
             # Check if this is a key-value line (contains ':' but not in quotes)
             if ':' in line:
                 # Find the first colon to identify the key
@@ -96,6 +107,11 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
                     fixed_lines.append(line)
                     continue
 
+                # Skip YAML list items (lines starting with '-')
+                if key == '' or line.strip().startswith('-'):
+                    fixed_lines.append(line)
+                    continue
+
                 # If value exists and is not quoted, we need to handle it
                 if value_part and not value_part.startswith('"') and not value_part.startswith("'"):
                     # Check if value contains unescaped colons that would break YAML
@@ -108,6 +124,70 @@ def _fix_yaml_frontmatter(cls, frontmatter: str) -> str:
 
         return '\n'.join(fixed_lines)
 
+    @classmethod
+    def _extract_frontmatter_by_regex(cls, frontmatter: str) -> Dict[str, Any]:
+        """Extract frontmatter fields using regex when YAML parsing fails.
+
+        This handles cases where YAML contains unexpected metadata or
+        formatting issues that break the parser.
+        """
+        result: Dict[str, Any] = {}
+
+        # Extract name field
+        name_match = re.search(r"^name:\s*(.+?)\s*$", frontmatter, re.MULTILINE)
+        if name_match:
+            result["name"] = name_match.group(1).strip().strip('"').strip("'")
+
+        # Extract description field
+        # Using non-greedy (.+?) will capture minimum, so "description: >" captures ">"
+        # Need to check if this is a block scalar first
+        desc_start_match = re.search(r"^description:\s*", frontmatter, re.MULTILINE)
+        if desc_start_match:
+            # Find the actual description line
+            lines = frontmatter.split('\n')
+            desc_line_idx = -1
+            for i, line in enumerate(lines):
+                if re.match(r"^description:\s*", line):
+                    desc_line_idx = i
+                    break
+
+            if desc_line_idx >= 0:
+                desc_line = lines[desc_line_idx]
+
+                # Check if it's a block scalar
+                has_block_scalar = re.match(r"^description:\s*[>|]", desc_line)
+                if has_block_scalar:
+                    # Collect all indented lines
+                    content_lines = []
+                    for line in lines[desc_line_idx + 1:]:
+                        # Empty line or non-indented line ends block
+                        if line.strip() == "":
+                            continue
+                        if not line.startswith(" ") and not line.startswith("\t"):
+                            break
+                        content_lines.append(line)
+                    description_text = " ".join([l.lstrip() for l in content_lines]).strip()
+                    result["description"] = description_text
+                else:
+                    # Single line value
+                    desc_match = re.search(r"^description:\s*(.+?)\s*$", desc_line)
+                    if desc_match:
+                        result["description"] = desc_match.group(1).strip().strip('"').strip("'")
+
+        # Extract tags field (YAML list format)
+        tags_match = re.search(r"^tags:\s*\[(.*?)\]\s*$", frontmatter, re.MULTILINE | re.DOTALL)
+        if tags_match:
+            tags_str = tags_match.group(1)
+            result["tags"] = [t.strip().strip('"').strip("'") for t in tags_str.split(",") if t.strip()]
+
+        # Extract allowed-tools field (YAML list format)
+        tools_match = re.search(r"^allowed-tools:\s*\[(.*?)\]\s*$", frontmatter, re.MULTILINE | re.DOTALL)
+        if tools_match:
+            tools_str = tools_match.group(1)
+            result["allowed-tools"] = [t.strip().strip('"').strip("'") for t in tools_str.split(",") if t.strip()]
+
+        return result
+
     @classmethod
     def _split_frontmatter(cls, content: str) -> Tuple[Optional[str], str]:
         """Split frontmatter and body."""
diff --git a/sdk/nexent/skills/skill_manager.py b/sdk/nexent/skills/skill_manager.py
index 08a69b98c..0cb2c9fdc 100644
--- a/sdk/nexent/skills/skill_manager.py
+++ b/sdk/nexent/skills/skill_manager.py
@@ -629,7 +629,7 @@ def escape_xml(s: str) -> str:
         lines.append("</skills>")
 
         return "\n".join(lines)
-    
+
 
     def load_skill_directory(self, name: str) -> Optional[Dict[str, Any]]:
         """Load entire skill directory including scripts.
diff --git a/test/backend/agents/test_create_agent_info.py b/test/backend/agents/test_create_agent_info.py
index d3631cd3f..1a133700b 100644
--- a/test/backend/agents/test_create_agent_info.py
+++ b/test/backend/agents/test_create_agent_info.py
@@ -182,7 +182,6 @@ def _create_stub_module(name: str, **attrs):
     prepare_prompt_templates,
     _get_skills_for_template,
     _get_skill_script_tools,
-    _print_prompt_with_token_count,
 )
 
 # Import constants for testing
@@ -433,88 +432,6 @@ def test_get_skill_script_tools_tool_descriptions(self):
                 assert "skill" in desc.lower()
 
 
-class TestPrintPromptWithTokenCount:
-    """Tests for the _print_prompt_with_token_count function"""
-
-    def test_print_prompt_with_token_count_success(self):
-        """Test successful token counting with tiktoken available"""
-        import tiktoken
-
-        with patch('backend.agents.create_agent_info.logger') as mock_logger:
-            mock_encoding = MagicMock()
-            mock_encoding.encode.return_value = ["token1", "token2", "token3"]
-            with patch.object(tiktoken, 'get_encoding', return_value=mock_encoding):
-                _print_prompt_with_token_count("test prompt content", agent_id=123, stage="TEST")
-
-                mock_encoding.encode.assert_called_once_with("test prompt content")
-                mock_logger.info.assert_called()
-
-                # Check that log messages contain expected content
-                log_calls = mock_logger.info.call_args_list
-                log_text = " ".join([str(call) for call in log_calls])
-                assert "TEST" in log_text
-                assert "123" in log_text
-                assert "3" in log_text  # Token count
-
-    def test_print_prompt_with_token_count_tiktoken_failure(self):
-        """Test graceful handling when tiktoken fails"""
-        import tiktoken
-
-        with patch('backend.agents.create_agent_info.logger') as mock_logger:
-            with patch.object(tiktoken, 'get_encoding', side_effect=Exception("tiktoken not available")):
-                _print_prompt_with_token_count("test prompt", agent_id=456, stage="FALLBACK")
-
-                # Should log a warning and then log the prompt
-                mock_logger.warning.assert_called_once()
-                assert "Failed to count tokens: tiktoken not available" in mock_logger.warning.call_args[0][0]
-
-                # Should still log the prompt
-                mock_logger.info.assert_called()
-
-    def test_print_prompt_with_token_count_default_stage(self):
-        """Test with default stage parameter"""
-        import tiktoken
-
-        with patch('backend.agents.create_agent_info.logger') as mock_logger:
-            mock_encoding = MagicMock()
-            mock_encoding.encode.return_value = ["a", "b"]
-            with patch.object(tiktoken, 'get_encoding', return_value=mock_encoding):
-                _print_prompt_with_token_count("short prompt")
-
-                log_calls = mock_logger.info.call_args_list
-                log_text = " ".join([str(call) for call in log_calls])
-                assert "PROMPT" in log_text  # Default stage
-
-    def test_print_prompt_with_token_count_empty_prompt(self):
-        """Test with empty prompt"""
-        import tiktoken
-
-        with patch('backend.agents.create_agent_info.logger') as mock_logger:
-            mock_encoding = MagicMock()
-            mock_encoding.encode.return_value = []
-            with patch.object(tiktoken, 'get_encoding', return_value=mock_encoding):
-                _print_prompt_with_token_count("", agent_id=1, stage="EMPTY")
-
-                mock_encoding.encode.assert_called_once_with("")
-                # Should log token count of 0
-                log_calls = mock_logger.info.call_args_list
-                log_text = " ".join([str(call) for call in log_calls])
-                assert "0" in log_text
-
-    def test_print_prompt_with_token_count_none_agent_id(self):
-        """Test with None agent_id"""
-        import tiktoken
-
-        with patch('backend.agents.create_agent_info.logger') as mock_logger:
-            mock_encoding = MagicMock()
-            mock_encoding.encode.return_value = ["token"]
-            with patch.object(tiktoken, 'get_encoding', return_value=mock_encoding):
-                _print_prompt_with_token_count("prompt", agent_id=None, stage="NO_ID")
-
-                # Should not raise an error
-                mock_encoding.encode.assert_called_once_with("prompt")
-
-
 class TestDiscoverLangchainTools:
     """Tests for the discover_langchain_tools function"""
 
@@ -779,7 +696,8 @@ async def test_create_tool_config_list_with_knowledge_base_tool_metadata(self):
         with patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
                 patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
                 patch('backend.agents.create_agent_info.get_vector_db_core') as mock_get_vector_db_core, \
-                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding:
+                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
 
             mock_search_tools.return_value = [
                 {
@@ -788,15 +706,21 @@ async def test_create_tool_config_list_with_knowledge_base_tool_metadata(self):
                     "description": "Knowledge search tool",
                     "inputs": "string",
                     "output_type": "string",
-                    "params": [{"name": "index_names", "default": []}],
+                    "params": [
+                        {"name": "index_names", "default": []},
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
                     "source": "local",
                     "usage": None
                 }
             ]
             mock_vdb_core = "mock_elastic_core"
             mock_embedding_model = "mock_embedding_model"
+            mock_rerank_model = "mock_rerank_model"
             mock_get_vector_db_core.return_value = mock_vdb_core
             mock_embedding.return_value = mock_embedding_model
+            mock_rerank.return_value = mock_rerank_model
 
             result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
 
@@ -807,10 +731,11 @@ async def test_create_tool_config_list_with_knowledge_base_tool_metadata(self):
             mock_get_vector_db_core.assert_called_once()
             mock_embedding.assert_called_once_with(tenant_id="tenant_1")
 
-            # Verify metadata contains ONLY vdb_core and embedding_model (no index_names or name_resolver)
+            # Verify metadata contains vdb_core, embedding_model and rerank_model
             expected_metadata = {
                 "vdb_core": mock_vdb_core,
                 "embedding_model": mock_embedding_model,
+                "rerank_model": mock_rerank.return_value,
             }
             assert mock_tool_instance.metadata == expected_metadata
 
@@ -834,7 +759,8 @@ async def test_create_tool_config_list_with_knowledge_base_tool_multiple_tools(s
                 patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
                 patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
                 patch('backend.agents.create_agent_info.get_vector_db_core') as mock_get_vector_db_core, \
-                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding:
+                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
 
             mock_tool_config.side_effect = [mock_tool_kb, mock_tool_other]
 
@@ -845,7 +771,11 @@ async def test_create_tool_config_list_with_knowledge_base_tool_multiple_tools(s
                     "description": "Knowledge search",
                     "inputs": "string",
                     "output_type": "string",
-                    "params": [],
+                    "params": [
+                        {"name": "index_names", "default": []},
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
                     "source": "local",
                     "usage": None
                 },
@@ -862,6 +792,7 @@ async def test_create_tool_config_list_with_knowledge_base_tool_multiple_tools(s
             ]
             mock_get_vector_db_core.return_value = "vdb_core_instance"
             mock_embedding.return_value = "embedding_instance"
+            mock_rerank.return_value = "rerank_instance"
 
             result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
 
@@ -871,6 +802,7 @@ async def test_create_tool_config_list_with_knowledge_base_tool_multiple_tools(s
             assert mock_tool_kb.metadata == {
                 "vdb_core": "vdb_core_instance",
                 "embedding_model": "embedding_instance",
+                "rerank_model": mock_rerank.return_value,
             }
 
             # Verify OtherTool has no special metadata (should not have metadata attribute set)
@@ -891,7 +823,8 @@ async def test_create_tool_config_list_with_knowledge_base_tool_mixed_sources(se
                 patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
                 patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
                 patch('backend.agents.create_agent_info.get_vector_db_core') as mock_get_vector_db_core, \
-                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding:
+                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
 
             mock_tool_config.return_value = mock_tool_instance
 
@@ -902,13 +835,17 @@ async def test_create_tool_config_list_with_knowledge_base_tool_mixed_sources(se
                     "description": "Knowledge search tool",
                     "inputs": "string",
                     "output_type": "string",
-                    "params": [],
+                    "params": [
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
                     "source": "mcp",
                     "usage": "mcp_server_1"
                 }
             ]
             mock_get_vector_db_core.return_value = "vdb_core"
             mock_embedding.return_value = "embedding"
+            mock_rerank.return_value = "rerank_model"
 
             result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
 
@@ -917,6 +854,7 @@ async def test_create_tool_config_list_with_knowledge_base_tool_mixed_sources(se
             assert mock_tool_instance.metadata == {
                 "vdb_core": "vdb_core",
                 "embedding_model": "embedding",
+                "rerank_model": mock_rerank.return_value,
             }
 
     @pytest.mark.asyncio
@@ -1023,7 +961,8 @@ async def test_create_tool_config_list_multiple_tools_same_type(self):
         with patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
                 patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
                 patch('backend.agents.create_agent_info.get_vector_db_core') as mock_get_vector_db_core, \
-                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding:
+                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
 
             mock_search_tools.return_value = [
                 {
@@ -1032,7 +971,10 @@ async def test_create_tool_config_list_multiple_tools_same_type(self):
                     "description": "First knowledge search",
                     "inputs": "string",
                     "output_type": "string",
-                    "params": [],
+                    "params": [
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
                     "source": "local",
                     "usage": None
                 },
@@ -1042,13 +984,17 @@ async def test_create_tool_config_list_multiple_tools_same_type(self):
                     "description": "Second knowledge search",
                     "inputs": "string",
                     "output_type": "string",
-                    "params": [],
+                    "params": [
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
                     "source": "local",
                     "usage": None
                 }
             ]
             mock_get_vector_db_core.return_value = "vdb_core"
             mock_embedding.return_value = "embedding"
+            mock_rerank.return_value = "rerank_model"
 
             result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
 
@@ -1058,10 +1004,173 @@ async def test_create_tool_config_list_multiple_tools_same_type(self):
             expected_metadata = {
                 "vdb_core": "vdb_core",
                 "embedding_model": "embedding",
+                "rerank_model": mock_rerank.return_value,
             }
             assert mock_tool_1.metadata == expected_metadata
             assert mock_tool_2.metadata == expected_metadata
 
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_with_dify_tool(self):
+        """Test that DifySearchTool gets correct metadata including rerank model."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "DifySearchTool"
+
+        with patch('backend.agents.create_agent_info.ToolConfig') as mock_tool_config, \
+                patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
+
+            mock_tool_config.return_value = mock_tool_instance
+            mock_rerank.return_value = "mock_rerank_model"
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "DifySearchTool",
+                    "name": "dify_search",
+                    "description": "Dify knowledge search",
+                    "inputs": "string",
+                    "output_type": "string",
+                    "params": [
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "gte-rerank-v2"},
+                    ],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+
+            from backend.agents.create_agent_info import create_tool_config_list
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            # Verify rerank model was fetched
+            mock_rerank.assert_called_once_with(
+                tenant_id="tenant_1", model_name="gte-rerank-v2"
+            )
+
+            # Verify metadata
+            assert len(result) == 1
+            assert result[0] is mock_tool_instance
+
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_with_dify_tool_no_rerank(self):
+        """Test that DifySearchTool without rerank gets None metadata."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "DifySearchTool"
+
+        with patch('backend.agents.create_agent_info.ToolConfig') as mock_tool_config, \
+                patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
+
+            mock_tool_config.return_value = mock_tool_instance
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "DifySearchTool",
+                    "name": "dify_search",
+                    "description": "Dify knowledge search",
+                    "inputs": "string",
+                    "output_type": "string",
+                    "params": [
+                        {"name": "rerank", "default": False},
+                        {"name": "rerank_model_name", "default": ""},
+                    ],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+
+            from backend.agents.create_agent_info import create_tool_config_list
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            # Verify rerank model was NOT fetched
+            mock_rerank.assert_not_called()
+
+            # Verify metadata
+            assert len(result) == 1
+            assert result[0] is mock_tool_instance
+
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_with_datamate_tool(self):
+        """Test that DataMateSearchTool gets correct metadata including rerank model."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "DataMateSearchTool"
+
+        with patch('backend.agents.create_agent_info.ToolConfig') as mock_tool_config, \
+                patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
+
+            mock_tool_config.return_value = mock_tool_instance
+            mock_rerank.return_value = "mock_datamate_rerank_model"
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "DataMateSearchTool",
+                    "name": "datamate_search",
+                    "description": "DataMate knowledge search",
+                    "inputs": "string",
+                    "output_type": "string",
+                    "params": [
+                        {"name": "rerank", "default": True},
+                        {"name": "rerank_model_name", "default": "jina-rerank-v2"},
+                    ],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+
+            from backend.agents.create_agent_info import create_tool_config_list
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            # Verify rerank model was fetched
+            mock_rerank.assert_called_once_with(
+                tenant_id="tenant_1", model_name="jina-rerank-v2"
+            )
+
+            # Verify metadata
+            assert len(result) == 1
+            assert result[0] is mock_tool_instance
+
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_with_datamate_tool_no_rerank(self):
+        """Test that DataMateSearchTool without rerank gets None metadata."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "DataMateSearchTool"
+
+        with patch('backend.agents.create_agent_info.ToolConfig') as mock_tool_config, \
+                patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_rerank_model') as mock_rerank:
+
+            mock_tool_config.return_value = mock_tool_instance
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "DataMateSearchTool",
+                    "name": "datamate_search",
+                    "description": "DataMate knowledge search",
+                    "inputs": "string",
+                    "output_type": "string",
+                    "params": [
+                        {"name": "rerank", "default": False},
+                        {"name": "rerank_model_name", "default": ""},
+                    ],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+
+            from backend.agents.create_agent_info import create_tool_config_list
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            # Verify rerank model was NOT fetched
+            mock_rerank.assert_not_called()
+
+            # Verify metadata
+            assert len(result) == 1
+            assert result[0] is mock_tool_instance
+
 
 class TestCreateAgentConfig:
     """Tests for the create_agent_config function"""
diff --git a/test/backend/app/test_knowledge_summary_app.py b/test/backend/app/test_knowledge_summary_app.py
index d932e90e4..ed8bb6972 100644
--- a/test/backend/app/test_knowledge_summary_app.py
+++ b/test/backend/app/test_knowledge_summary_app.py
@@ -20,11 +20,31 @@
 sys.modules['botocore.client'] = MagicMock()
 sys.modules['botocore.exceptions'] = MagicMock()
 sys.modules['nexent'] = MagicMock()
-sys.modules['nexent.core'] = MagicMock()
-sys.modules['nexent.core.agents'] = MagicMock()
-sys.modules['nexent.core.agents.agent_model'] = MagicMock()
-sys.modules['nexent.core.models'] = MagicMock()
-sys.modules['nexent.core.models.embedding_model'] = MagicMock()
+nexent_core = types.ModuleType('nexent.core')
+sys.modules['nexent.core'] = nexent_core
+nexent_core_agents = types.ModuleType('nexent.core.agents')
+sys.modules['nexent.core.agents'] = nexent_core_agents
+nexent_core_agents_agent_model = types.ModuleType('nexent.core.agents.agent_model')
+sys.modules['nexent.core.agents.agent_model'] = nexent_core_agents_agent_model
+
+# nexent.core.models must be a ModuleType (not MagicMock) to allow submodules
+nexent_core_models = types.ModuleType('nexent.core.models')
+sys.modules['nexent.core.models'] = nexent_core_models
+sys.modules['nexent.core.models.embedding_model'] = types.ModuleType('nexent.core.models.embedding_model')
+
+# Mock rerank_model module with proper class exports
+class MockBaseRerank:
+    pass
+
+class MockOpenAICompatibleRerank(MockBaseRerank):
+    def __init__(self, *args, **kwargs):
+        pass
+
+rerank_module = MagicMock()
+rerank_module.BaseRerank = MockBaseRerank
+rerank_module.OpenAICompatibleRerank = MockOpenAICompatibleRerank
+sys.modules['nexent.core.models.rerank_model'] = rerank_module
+
 sys.modules['nexent.core.models.stt_model'] = MagicMock()
 sys.modules['nexent.core.models.tts_model'] = MagicMock()
 sys.modules['nexent.core.nlp'] = MagicMock()
diff --git a/test/backend/app/test_skill_app.py b/test/backend/app/test_skill_app.py
index 3dbe643a0..4e14923c8 100644
--- a/test/backend/app/test_skill_app.py
+++ b/test/backend/app/test_skill_app.py
@@ -51,6 +51,31 @@ class SkillInstanceInfoRequest(BaseModel):
 # Mock ToolConfig from agent_model
 nexent_core_agents_agent_model_mock.ToolConfig = type('ToolConfig', (), {})
 
+# ModelConfig mock that accepts kwargs
+class MockModelConfig:
+    def __init__(
+        self,
+        cite_name: str = None,
+        api_key: str = None,
+        model_name: str = None,
+        url: str = None,
+        temperature: float = None,
+        top_p: float = None,
+        ssl_verify: bool = None,
+        model_factory: str = None,
+        **kwargs
+    ):
+        self.cite_name = cite_name
+        self.api_key = api_key
+        self.model_name = model_name
+        self.url = url
+        self.temperature = temperature
+        self.top_p = top_p
+        self.ssl_verify = ssl_verify
+        self.model_factory = model_factory
+
+nexent_core_agents_agent_model_mock.ModelConfig = MockModelConfig
+
 # Set up storage mocks
 storage_client_mock = MagicMock()
 nexent_storage_storage_client_factory_mock.create_storage_client_from_config = MagicMock(return_value=storage_client_mock)
@@ -71,9 +96,12 @@ def __init__(self, local_skills_dir=None, **kwargs):
 consts_mock = types.ModuleType('consts')
 consts_exceptions_mock = types.ModuleType('consts.exceptions')
 consts_model_mock = types.ModuleType('consts.model')
+consts_const_mock = types.ModuleType('consts.const')
 sys.modules['consts'] = consts_mock
 sys.modules['consts.exceptions'] = consts_exceptions_mock
 sys.modules['consts.model'] = consts_model_mock
+sys.modules['consts.const'] = consts_const_mock
+consts_const_mock.MODEL_CONFIG_MAPPING = {"llm": "llm_model"}
 
 class SkillException(Exception):
     pass
@@ -100,9 +128,36 @@ def __init__(self):
 # Mock utils
 utils_mock = types.ModuleType('utils')
 utils_auth_utils_mock = types.ModuleType('utils.auth_utils')
+utils_config_utils_mock = types.ModuleType('utils.config_utils')
 sys.modules['utils'] = utils_mock
 sys.modules['utils.auth_utils'] = utils_auth_utils_mock
+sys.modules['utils.config_utils'] = utils_config_utils_mock
 utils_auth_utils_mock.get_current_user_id = MagicMock(return_value=("user123", "tenant123"))
+utils_auth_utils_mock.get_current_user_info = MagicMock(return_value=("user123", "tenant123", "zh"))
+utils_config_utils_mock.tenant_config_manager = MagicMock()
+utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+# Mock utils.prompt_template_utils
+utils_prompt_template_utils_mock = types.ModuleType('utils.prompt_template_utils')
+sys.modules['utils.prompt_template_utils'] = utils_prompt_template_utils_mock
+utils_prompt_template_utils_mock.get_skill_creation_simple_prompt_template = MagicMock(return_value={
+    "system_prompt": "You are a skill creator",
+    "user_prompt": "Create a skill"
+})
+
+# Mock agents module
+agents_mock = types.ModuleType('agents')
+agents_skill_creation_agent_mock = types.ModuleType('agents.skill_creation_agent')
+sys.modules['agents'] = agents_mock
+sys.modules['agents.skill_creation_agent'] = agents_skill_creation_agent_mock
+agents_skill_creation_agent_mock.create_simple_skill_from_request = MagicMock()
+
+# Mock nexent.core.utils
+nexent_core_utils_mock = types.ModuleType('nexent.core.utils')
+nexent_core_utils_observer_mock = types.ModuleType('nexent.core.utils.observer')
+sys.modules['nexent.core.utils'] = nexent_core_utils_mock
+sys.modules['nexent.core.utils.observer'] = nexent_core_utils_observer_mock
+nexent_core_utils_observer_mock.MessageObserver = type('MessageObserver', (), {})
 
 # Mock database
 database_mock = types.ModuleType('database')
@@ -1791,203 +1846,6 @@ def test_create_skill_unexpected_error(self, mocker):
                 assert response.status_code == 500
 
 
-# ===== Delete Skill File Endpoint Tests =====
-class TestDeleteSkillFileEndpoint:
-    """Test DELETE /skills/{skill_name}/files/{file_path} endpoint."""
-
-    def test_delete_skill_file_success(self, mocker):
-        """Test successful deletion of skill file."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                with patch('os.path.exists', return_value=True):
-                    with patch('os.remove'):
-                        mock_auth.return_value = ("user123", "tenant123")
-                        mock_service = MagicMock()
-                        mock_service_class.return_value = mock_service
-                        mock_service.get_skill_file_content.return_value = "temp_filename: temp.yaml"
-                        mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                        app = FastAPI()
-                        app.include_router(skill_app.router)
-                        client = TestClient(app)
-
-                        response = client.delete(
-                            "/skills/test_skill/files/temp.yaml",
-                            headers={"Authorization": "Bearer token123"}
-                        )
-
-                        assert response.status_code == 200
-                        assert "deleted successfully" in response.json()["message"]
-
-    def test_delete_skill_file_config_not_found(self, mocker):
-        """Test delete file when config.yaml not found."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = None
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/temp.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 404
-
-    def test_delete_skill_file_invalid_filename(self, mocker):
-        """Test delete file with filename not matching temp_filename."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: actual_temp.yaml"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/wrong_file.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-
-    def test_delete_skill_file_not_exists(self, mocker):
-        """Test delete file that doesn't exist on disk."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                with patch('os.path.exists', return_value=False):
-                    mock_auth.return_value = ("user123", "tenant123")
-                    mock_service = MagicMock()
-                    mock_service_class.return_value = mock_service
-                    mock_service.get_skill_file_content.return_value = "temp_filename: temp.yaml"
-                    mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                    app = FastAPI()
-                    app.include_router(skill_app.router)
-                    client = TestClient(app)
-
-                    response = client.delete(
-                        "/skills/test_skill/files/temp.yaml",
-                        headers={"Authorization": "Bearer token123"}
-                    )
-
-                    assert response.status_code == 404
-
-    def test_delete_skill_file_unauthorized(self, mocker):
-        """Test delete file without authorization."""
-        from backend.apps.skill_app import UnauthorizedError
-        with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-            mock_auth.side_effect = UnauthorizedError("No token")
-
-            app = FastAPI()
-            app.include_router(skill_app.router)
-            client = TestClient(app)
-
-            response = client.delete(
-                "/skills/test_skill/files/temp.yaml",
-                headers={"Authorization": "Bearer invalid"}
-            )
-
-            assert response.status_code == 401
-
-    def test_delete_skill_file_unexpected_error(self, mocker):
-        """Test delete file with unexpected error."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.side_effect = Exception("Unexpected error")
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/temp.yaml",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 500
-
-    def test_delete_skill_file_path_traversal_dotdot(self, mocker):
-        """Test path traversal with ../ is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: ../../etc/passwd"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/..%2F..%2Fetc%2Fpasswd",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-    def test_delete_skill_file_path_traversal_absolute(self, mocker):
-        """Test path traversal with absolute path is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                mock_service.get_skill_file_content.return_value = "temp_filename: /etc/passwd"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                response = client.delete(
-                    "/skills/test_skill/files/%2Fetc%2Fpasswd",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-    def test_delete_skill_file_path_traversal_with_encoded_separators(self, mocker):
-        """Test path traversal with encoded path separators is blocked."""
-        with patch('backend.apps.skill_app.SkillService') as mock_service_class:
-            with patch('backend.apps.skill_app.get_current_user_id') as mock_auth:
-                mock_auth.return_value = ("user123", "tenant123")
-                mock_service = MagicMock()
-                mock_service_class.return_value = mock_service
-                # The temp_filename must match what comes after /files/ in the URL
-                # FastAPI decodes %2F to /, so the actual file_path will be ../../windows/system32
-                mock_service.get_skill_file_content.return_value = "temp_filename: ../../windows/system32"
-                mock_service.skill_manager.local_skills_dir = "/tmp/skills"
-
-                app = FastAPI()
-                app.include_router(skill_app.router)
-                client = TestClient(app)
-
-                # URL encoded ../../
-                response = client.delete(
-                    "/skills/test_skill/files/..%252F..%252Fwindows%252Fsystem32",
-                    headers={"Authorization": "Bearer token123"}
-                )
-
-                assert response.status_code == 400
-                assert "path traversal" in response.json()["detail"].lower()
-
-
 # ===== Update Skill Instance Endpoint Error Handling Tests =====
 class TestUpdateSkillInstanceEndpointErrorHandling:
     """Error handling tests for POST /skills/instance/update endpoint."""
@@ -2167,5 +2025,1303 @@ def test_update_skill_with_tool_ids_only(self, mocker):
                 assert response.status_code == 200
 
 
+# ===== Create Simple Skill Endpoint Tests =====
+class TestCreateSimpleSkillEndpoint:
+    """Test POST /skills/create-simple endpoint (SSE streaming)."""
+
+    def test_create_simple_skill_success(self, mocker):
+        """Test successful simple skill creation with streaming response."""
+        # Mock dependencies
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.return_value = []
+        mock_observer_instance.get_final_answer.return_value = "<SKILL>\n# Test Skill\n</SKILL>"
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a greeting skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_create_simple_skill_with_streaming_messages(self, mocker):
+        """Test streaming messages are properly sent."""
+        # Mock dependencies
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        # Return cached messages that will be streamed
+        cached_messages = [
+            '{"type": "step_count", "content": "1"}',
+            '{"type": "model_output_thinking", "content": "Thinking..."}',
+            '{"type": "tool", "content": "Tool executed"}',
+            '{"type": "final_answer", "content": "<SKILL>Content</SKILL>"}'
+        ]
+        mock_observer_instance.get_cached_message.side_effect = [
+            cached_messages[:2],
+            cached_messages[2:],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = "<SKILL>Final Content</SKILL>"
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a test skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_create_simple_skill_unauthorized(self, mocker):
+        """Test create simple skill without authorization - error is sent via SSE stream."""
+        from backend.apps.skill_app import UnauthorizedError
+
+        mocker.patch(
+            'backend.apps.skill_app.get_current_user_info',
+            side_effect=UnauthorizedError("No token")
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a skill"},
+            headers={"Authorization": "Bearer invalid"}
+        )
+
+        # Exception is caught in generate() and returned as 200 with SSE error event
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+        # SSE stream contains error event
+        assert b'"type": "error"' in response.content
+        assert b'No token' in response.content
+
+
+# ===== Build Model Config Tests =====
+class TestBuildModelConfigFromTenant:
+    """Test _build_model_config_from_tenant function."""
+
+    def test_build_model_config_success(self, mocker):
+        """Test successful ModelConfig building."""
+        # Set up mocks for the config utilities
+        mock_config_manager_instance = MagicMock()
+        mock_config_manager_instance.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+
+        utils_config_utils_mock.tenant_config_manager = mock_config_manager_instance
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4-0613")
+
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'tenant_config_manager',
+            mock_config_manager_instance
+        )
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'get_model_name_from_config',
+            return_value="gpt-4-0613"
+        )
+
+        result = skill_app._build_model_config_from_tenant("tenant123")
+
+        assert result.cite_name == "gpt-4"
+        assert result.api_key == "test-key"
+        assert result.url == "https://api.openai.com"
+        assert result.model_factory == "openai"
+
+    def test_build_model_config_no_llm_config(self, mocker):
+        """Test ValueError when no LLM model configured for tenant."""
+        mock_config_manager_instance = MagicMock()
+        mock_config_manager_instance.get_model_config.return_value = None
+
+        mocker.patch.object(
+            utils_config_utils_mock,
+            'tenant_config_manager',
+            mock_config_manager_instance
+        )
+
+        with pytest.raises(ValueError, match="No LLM model configured for tenant"):
+            skill_app._build_model_config_from_tenant("tenant123")
+
+
+# ===== Stream Content Types Tests =====
+class TestStreamContentTypes:
+    """Test different content types in streaming response."""
+
+    def test_stream_model_output_code(self, mocker):
+        """Test streaming model_output_code content."""
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.side_effect = [
+            ['{"type": "model_output_code", "content": "def hello(): pass"}'],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = None
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a code skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_stream_deep_thinking(self, mocker):
+        """Test streaming model_output_deep_thinking content."""
+        mock_user_info = patch('backend.apps.skill_app.get_current_user_info')
+        mock_user_info.return_value = ("user123", "tenant123", "zh")
+        mock_user_info.start()
+
+        mock_template = patch('backend.apps.skill_app.get_skill_creation_simple_prompt_template')
+        mock_template.return_value = {
+            "system_prompt": "You are a skill creator",
+            "user_prompt": "Create a skill"
+        }
+        mock_template.start()
+
+        mock_observer = patch('backend.apps.skill_app.MessageObserver')
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message.side_effect = [
+            ['{"type": "model_output_deep_thinking", "content": "Deep thought process"}'],
+            []
+        ]
+        mock_observer_instance.get_final_answer.return_value = None
+        mock_observer.return_value = mock_observer_instance
+        mock_observer.start()
+
+        mock_service = patch('backend.apps.skill_app.SkillService')
+        mock_service_instance = MagicMock()
+        mock_service_instance.skill_manager = MagicMock()
+        mock_service_instance.skill_manager.local_skills_dir = "/tmp/skills"
+        mock_service.return_value = mock_service_instance
+        mock_service.start()
+
+        mock_create = patch('backend.apps.skill_app.create_simple_skill_from_request')
+        mock_create.start()
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a thinking skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+
+        mock_user_info.stop()
+        mock_template.stop()
+        mock_observer.stop()
+        mock_service.stop()
+        mock_create.stop()
+
+    def test_stream_execution_logs(self, mocker):
+        """Test streaming execution_logs content."""
+        # Rely on module-level mocks for basic test
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create a logging skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+
+# ===== Streaming Flow Tests =====
+class TestStreamingFlow:
+    """Test the complete streaming flow including thread polling and final results."""
+
+    def _setup_streaming_mocks(self, mocker, cached_messages_list, final_answer, skill_service_local_dir=None):
+        """Helper to set up comprehensive mocks for streaming tests."""
+        # Set up config utils mocks
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        # Create mock observer that returns messages on each call
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=cached_messages_list)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=final_answer)
+
+        # Create mock MessageObserver class
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        # Create mock SkillService
+        mock_skill_service_instance = MagicMock()
+        mock_skill_manager = MagicMock()
+        mock_skill_manager.local_skills_dir = skill_service_local_dir
+        mock_skill_service_instance.skill_manager = mock_skill_manager
+        mocker.patch(
+            'backend.apps.skill_app.SkillService',
+            return_value=mock_skill_service_instance
+        )
+
+        # Mock create_simple_skill_from_request to be a no-op (background task)
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        return mock_observer_instance, mock_skill_service_instance
+
+    def test_streaming_with_step_count_messages(self, mocker):
+        """Test streaming step_count messages during polling (lines 557-558, 580-581)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}'],
+            ['{"type": "step_count", "content": "2"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with steps"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+        assert mock_observer.get_cached_message.call_count >= 1
+
+    def test_streaming_with_skill_content_messages(self, mocker):
+        """Test streaming skill_content messages (thinking, code, etc.) during polling (lines 560-561, 582-583)."""
+        cached_messages = [
+            ['{"type": "model_output_thinking", "content": "Thinking about the skill..."}'],
+            ['{"type": "model_output_code", "content": "# SKILL.md\\ncontent"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with content"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Thinking about the skill' in response.content
+
+    def test_streaming_with_final_answer_during_polling(self, mocker):
+        """Test streaming final_answer during polling phase (lines 563-564, 584-585)."""
+        cached_messages = [
+            [],
+            ['{"type": "final_answer", "content": "Partial answer during poll"}'],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\nFinal Answer</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with final answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "final_answer"' in response.content
+        assert b'Final Answer' in response.content
+
+    def test_streaming_remaining_messages_after_thread(self, mocker):
+        """Test streaming remaining messages after thread completes (lines 572-587)."""
+        # Note: Due to mock behavior, thread completes immediately without producing messages.
+        # This test verifies the streaming endpoint works correctly even without messages.
+        cached_messages = [
+            [],  # During polling
+            [],  # After thread
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Final Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with remaining"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Should still work and send done signal
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_final_result_from_observer(self, mocker):
+        """Test streaming final result from observer after thread completes (lines 590-592)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\n# Complete Skill Content\nThis is the final result.</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create complete skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'Complete Skill Content' in response.content
+        assert b'"type": "final_answer"' in response.content
+
+    def test_streaming_done_signal(self, mocker):
+        """Test streaming done signal at the end (line 595)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill and finish"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_empty_final_answer(self, mocker):
+        """Test streaming when final_answer is None/empty (lines 591-592)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer=None,
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with no final answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+        assert response.content.count(b'"type": "final_answer"') <= 1
+
+    def test_streaming_with_empty_local_skills_dir(self, mocker):
+        """Test streaming with None local_skills_dir (line 530)."""
+        cached_messages = [
+            [],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir=None
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with no skills dir"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_tool_messages(self, mocker):
+        """Test streaming tool messages (lines 560-561, 582-583)."""
+        cached_messages = [
+            ['{"type": "tool", "content": "Writing file: SKILL.md"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\n# Tool Result</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill using tools"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Writing file' in response.content
+
+    def test_streaming_with_mixed_message_types(self, mocker):
+        """Test streaming with mixed message types across polling and remaining phases."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', '{"type": "model_output_thinking", "content": "Thinking"}'],
+            ['{"type": "tool", "content": "Tool executed"}', '{"type": "final_answer", "content": "Partial"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>\nFinal Complete Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create complex skill"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+        assert b'"type": "skill_content"' in response.content
+        assert b'"type": "final_answer"' in response.content
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_json_decode_error_in_message(self, mocker):
+        """Test handling of invalid JSON in cached messages (lines 565-566, 586-587)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', 'invalid json {{{', '{"type": "model_output_thinking", "content": "Valid"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with bad json"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+    def test_streaming_with_non_string_message(self, mocker):
+        """Test handling of non-string messages in cached messages (lines 550, 574)."""
+        cached_messages = [
+            ['{"type": "step_count", "content": "1"}', 123, None, '{"type": "model_output_thinking", "content": "Valid"}'],
+            [],
+        ]
+
+        mock_observer, _ = self._setup_streaming_mocks(
+            mocker,
+            cached_messages_list=cached_messages,
+            final_answer="<SKILL>Skill</SKILL>",
+            skill_service_local_dir="/tmp/skills"
+        )
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with weird messages"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "done"' in response.content
+
+
+# ===== Thread Polling Tests =====
+class TestThreadPolling:
+    """Test thread polling behavior and message streaming during polling phase."""
+
+    def _setup_thread_polling_mocks(self, mocker, observer_messages_per_poll, skill_service_local_dir="/tmp/skills"):
+        """Set up mocks for thread polling tests.
+
+        Args:
+            observer_messages_per_poll: List of message lists, each returned on successive calls to get_cached_message
+        """
+        # Set up config utils mocks
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        # Track which call we're on
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages_per_poll):
+                return observer_messages_per_poll[idx]
+            return []
+
+        # Create mock observer
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        # Track thread state to control polling behavior
+        thread_polled = [False]
+
+        def create_mock_thread():
+            """Create a mock thread that stays alive for multiple polls."""
+            import time
+            poll_count = [0]
+            max_polls = len(observer_messages_per_poll)
+
+            class MockThread:
+                def is_alive(self):
+                    poll_count[0] += 1
+                    # Stay alive for the first few polls, then die
+                    if poll_count[0] < max_polls:
+                        thread_polled[0] = True
+                        return True
+                    return False
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        return mock_observer_instance, thread_polled, create_mock_thread
+
+    def test_polling_loop_executes_multiple_times(self, mocker):
+        """Test that the polling loop executes multiple times while thread is alive (lines 547-567)."""
+        # Set up 3 polls worth of messages
+        observer_messages = [
+            ['{"type": "step_count", "content": "1"}'],
+            ['{"type": "model_output_thinking", "content": "Thinking..."}'],
+            [],  # Thread dies after this poll
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with polling"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Verify observer was polled multiple times
+        assert mock_observer_instance.get_cached_message.call_count >= 2
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_with_step_count_streaming(self, mocker):
+        """Test step_count messages are streamed during polling (lines 557-558)."""
+        observer_messages = [
+            ['{"type": "step_count", "content": "1"}', '{"type": "step_count", "content": "2"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value=None)
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with steps"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_with_skill_content_streaming(self, mocker):
+        """Test skill_content messages are streamed during polling (lines 560-561)."""
+        observer_messages = [
+            ['{"type": "model_output_thinking", "content": "Thinking step 1"}', '{"type": "model_output_code", "content": "Code block"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with content"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        assert b'"type": "skill_content"' in response.content
+        assert b'Thinking step 1' in response.content
+
+    def test_polling_with_final_answer_during_polling(self, mocker):
+        """Test final_answer messages during polling are streamed (lines 563-564)."""
+        # final_answer must arrive while thread is still alive (not in remaining messages)
+        observer_messages = [
+            ['{"type": "final_answer", "content": "Partial answer in poll"}'],  # Thread is alive
+            [],  # Thread dies after this poll
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        # Thread stays alive for max_polls-1 polls, dies on the last one
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    # Stay alive while we have more polls to do
+                    if poll_count[0] <= max_polls - 1:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with partial answer"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Verify final_answer was streamed during polling
+        assert b'"type": "final_answer"' in response.content
+        assert b'Partial answer in poll' in response.content
+
+    def test_polling_skips_non_string_messages(self, mocker):
+        """Test that non-string messages are skipped (line 550)."""
+        observer_messages = [
+            [123, None, '{"type": "step_count", "content": "1"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Skill</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with mixed messages"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        # Should handle gracefully and only stream the valid string message
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_polling_handles_json_decode_error(self, mocker):
+        """Test that JSON decode errors are caught and ignored (lines 565-566)."""
+        observer_messages = [
+            ['{"invalid json', '{"type": "step_count", "content": "1"}'],
+            [],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Skill</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with bad json"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        # Should handle gracefully and continue streaming valid messages
+        assert response.status_code == 200
+        assert b'"type": "step_count"' in response.content
+
+    def test_remaining_messages_after_thread_with_step_count(self, mocker):
+        """Test remaining messages with step_count after thread completes (lines 580-581, 584-585)."""
+        observer_messages = [
+            [],
+            ['{"type": "step_count", "content": "Final step"}', '{"type": "final_answer", "content": "Partial"}'],
+        ]
+
+        utils_config_utils_mock.tenant_config_manager = MagicMock()
+        utils_config_utils_mock.tenant_config_manager.get_model_config.return_value = {
+            "display_name": "gpt-4",
+            "api_key": "test-key",
+            "base_url": "https://api.openai.com",
+            "model_factory": "openai"
+        }
+        utils_config_utils_mock.get_model_name_from_config = MagicMock(return_value="gpt-4")
+
+        call_count = [0]
+
+        def get_cached_message_side_effect():
+            idx = call_count[0]
+            call_count[0] += 1
+            if idx < len(observer_messages):
+                return observer_messages[idx]
+            return []
+
+        mock_observer_instance = MagicMock()
+        mock_observer_instance.get_cached_message = MagicMock(side_effect=get_cached_message_side_effect)
+        mock_observer_instance.get_final_answer = MagicMock(return_value="<SKILL>Final Complete</SKILL>")
+
+        mocker.patch(
+            'backend.apps.skill_app.MessageObserver',
+            return_value=mock_observer_instance
+        )
+
+        mocker.patch(
+            'backend.apps.skill_app.create_simple_skill_from_request'
+        )
+
+        poll_count = [0]
+        max_polls = len(observer_messages)
+
+        def mock_thread_init(target=None):
+            poll_count[0] = 0
+            class MockThread:
+                def is_alive(self):
+                    nonlocal poll_count
+                    poll_count[0] += 1
+                    if poll_count[0] < max_polls:
+                        return True
+                    return False
+
+                def start(self):
+                    pass
+
+                def join(self):
+                    pass
+
+            return MockThread()
+
+        mocker.patch('threading.Thread', side_effect=mock_thread_init)
+
+        app = FastAPI()
+        app.include_router(skill_app.skill_creator_router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/skills/create-simple",
+            json={"user_request": "Create skill with remaining"},
+            headers={"Authorization": "Bearer token123"}
+        )
+
+        assert response.status_code == 200
+        # Should have streamed step_count from remaining messages
+        assert b'"type": "step_count"' in response.content
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
diff --git a/test/backend/services/providers/test_dashscope_provider.py b/test/backend/services/providers/test_dashscope_provider.py
index 0bc2d3ad8..30229677a 100644
--- a/test/backend/services/providers/test_dashscope_provider.py
+++ b/test/backend/services/providers/test_dashscope_provider.py
@@ -173,15 +173,15 @@ async def test_get_models_vlm_success(self, mocker: MockFixture):
         assert result[0]["model_tag"] == "chat"
 
     @pytest.mark.asyncio
-    async def test_get_models_reranker_success(self, mocker: MockFixture):
-        """Test successful model retrieval for reranker models."""
+    async def test_get_models_rerank_success(self, mocker: MockFixture):
+        """Test successful model retrieval for rerank models."""
         mock_response = MagicMock()
         mock_response.status_code = 200
         mock_response.json.return_value = {
             "output": {
                 "models": [
                     {
-                        "model": "gte-reranker",
+                        "model": "gte-rerank",
                         "description": "Reranking model",
                         "inference_metadata": {
                             "request_modality": ["Text"],
@@ -202,16 +202,16 @@ async def test_get_models_reranker_success(self, mocker: MockFixture):
 
         provider = DashScopeModelProvider()
         provider_config = {
-            "model_type": "reranker",
+            "model_type": "rerank",
             "api_key": "test-api-key"
         }
 
         result = await provider.get_models(provider_config)
 
         assert len(result) == 1
-        assert result[0]["id"] == "gte-reranker"
-        assert result[0]["model_type"] == "reranker"
-        assert result[0]["model_tag"] == "reranker"
+        assert result[0]["id"] == "gte-rerank"
+        assert result[0]["model_type"] == "rerank"
+        assert result[0]["model_tag"] == "rerank"
 
     @pytest.mark.asyncio
     async def test_get_models_tts_success(self, mocker: MockFixture):
@@ -663,7 +663,7 @@ async def test_get_models_with_chinese_description(self, mocker: MockFixture):
         assert len(result) == 1
         assert result[0]["id"] == "embedding-v1"
 
-        # Test reranker classification by Chinese description
-        result = await provider.get_models({"model_type": "reranker", "api_key": "test-key"})
+        # Test rerank classification by Chinese description
+        result = await provider.get_models({"model_type": "rerank", "api_key": "test-key"})
         assert len(result) == 1
         assert result[0]["id"] == "rerank-v1"
diff --git a/test/backend/services/providers/test_silicon_provider.py b/test/backend/services/providers/test_silicon_provider.py
index 8a13c6de9..b947040c3 100644
--- a/test/backend/services/providers/test_silicon_provider.py
+++ b/test/backend/services/providers/test_silicon_provider.py
@@ -501,3 +501,80 @@ async def test_get_models_llm_has_max_tokens(self, mocker: MockFixture):
 
         assert len(result) == 1
         assert result[0]["max_tokens"] == 4096
+
+    @pytest.mark.asyncio
+    async def test_get_models_rerank_success(self, mocker: MockFixture):
+        """Test successful model retrieval for rerank models."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": [
+                {"id": "gte-rerank-v2", "name": "GTE Rerank V2"},
+            ]
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.get.return_value = mock_response
+
+        mock_cm = MagicMock()
+        mock_cm.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_cm.__aexit__ = AsyncMock(return_value=None)
+
+        mocker.patch(
+            "backend.services.providers.silicon_provider.httpx.AsyncClient",
+            return_value=mock_cm
+        )
+        mocker.patch(
+            "backend.services.providers.silicon_provider.SILICON_GET_URL",
+            "https://api.siliconflow.com/v1/models"
+        )
+
+        provider = SiliconModelProvider()
+        provider_config = {
+            "model_type": "rerank",
+            "api_key": "test-api-key"
+        }
+
+        result = await provider.get_models(provider_config)
+
+        assert len(result) == 1
+        assert result[0]["id"] == "gte-rerank-v2"
+        assert result[0]["model_type"] == "rerank"
+        assert result[0]["model_tag"] == "rerank"
+
+    @pytest.mark.asyncio
+    async def test_get_models_correct_url_for_rerank(self, mocker: MockFixture):
+        """Test that correct URL is used for rerank models."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": [{"id": "test"}]}
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.get.return_value = mock_response
+
+        mock_cm = MagicMock()
+        mock_cm.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_cm.__aexit__ = AsyncMock(return_value=None)
+
+        mocker.patch(
+            "backend.services.providers.silicon_provider.httpx.AsyncClient",
+            return_value=mock_cm
+        )
+        mocker.patch(
+            "backend.services.providers.silicon_provider.SILICON_GET_URL",
+            "https://api.siliconflow.com/models"
+        )
+
+        provider = SiliconModelProvider()
+        provider_config = {
+            "model_type": "rerank",
+            "api_key": "test-api-key"
+        }
+
+        await provider.get_models(provider_config)
+
+        # Verify the URL contains sub_type=reranker for rerank
+        call_args = mock_client.get.call_args
+        assert "sub_type=reranker" in call_args[0][0]
diff --git a/test/backend/services/providers/test_tokenpony_provider.py b/test/backend/services/providers/test_tokenpony_provider.py
index 7fd9df9eb..e93d8ba7b 100644
--- a/test/backend/services/providers/test_tokenpony_provider.py
+++ b/test/backend/services/providers/test_tokenpony_provider.py
@@ -161,14 +161,14 @@ async def test_get_models_vlm_success(self, mocker: MockFixture):
         assert result[0]["model_tag"] == "chat"
 
     @pytest.mark.asyncio
-    async def test_get_models_reranker_success(self, mocker: MockFixture):
-        """Test successful model retrieval for reranker models."""
+    async def test_get_models_rerank_success(self, mocker: MockFixture):
+        """Test successful model retrieval for rerank models."""
         mock_response = MagicMock()
         mock_response.status_code = 200
         mock_response.json.return_value = {
             "data": [
                 {
-                    "id": "gte-reranker-base",
+                    "id": "gte-rerank-base",
                     "object": "model",
                     "owned_by": "gte"
                 }
@@ -194,16 +194,16 @@ async def test_get_models_reranker_success(self, mocker: MockFixture):
 
         provider = TokenPonyModelProvider()
         provider_config = {
-            "model_type": "reranker",
+            "model_type": "rerank",
             "api_key": "test-api-key"
         }
 
         result = await provider.get_models(provider_config)
 
         assert len(result) == 1
-        assert result[0]["id"] == "gte-reranker-base"
-        assert result[0]["model_type"] == "reranker"
-        assert result[0]["model_tag"] == "reranker"
+        assert result[0]["id"] == "gte-rerank-base"
+        assert result[0]["model_type"] == "rerank"
+        assert result[0]["model_tag"] == "rerank"
 
     @pytest.mark.asyncio
     async def test_get_models_tts_success(self, mocker: MockFixture):
diff --git a/test/backend/services/test_agent_service.py b/test/backend/services/test_agent_service.py
index 2c37f89db..479223150 100644
--- a/test/backend/services/test_agent_service.py
+++ b/test/backend/services/test_agent_service.py
@@ -88,6 +88,72 @@ def mock_convert_list_to_string(items):
         return ""
     return ",".join(str(item) for item in items)
 
+    import backend.services.agent_service as agent_service
+    from backend.services.agent_service import update_agent_info_impl
+    from backend.services.agent_service import get_creating_sub_agent_info_impl
+    from backend.services.agent_service import list_all_agent_info_impl
+    from backend.services.agent_service import get_agent_info_impl
+    from backend.services.agent_service import get_creating_sub_agent_id_service
+    from backend.services.agent_service import get_enable_tool_id_by_agent_id
+    from backend.services.agent_service import (
+        get_agent_call_relationship_impl,
+        delete_agent_impl,
+        export_agent_impl,
+        export_agent_by_agent_id,
+        import_agent_by_agent_id,
+        insert_related_agent_impl,
+        load_default_agents_json_file,
+        clear_agent_memory,
+        import_agent_impl,
+        get_agent_id_by_name,
+        save_messages,
+        prepare_agent_run,
+        run_agent_stream,
+        stop_agent_tasks,
+        _resolve_user_tenant_language,
+        _apply_duplicate_name_availability_rules,
+        _check_single_model_availability,
+        _normalize_language_key,
+        _render_prompt_template,
+        _format_existing_values,
+        _generate_unique_agent_name_with_suffix,
+        _generate_unique_display_name_with_suffix,
+        _generate_unique_value_with_suffix,
+        _regenerate_agent_value_with_llm,
+        clear_agent_new_mark_impl,
+    )
+    from consts.model import ExportAndImportAgentInfo, ExportAndImportDataFormat, MCPInfo, AgentRequest
+
+    # Ensure db_client is set to our mock after import
+    import backend.database.client as db_client_module
+    db_client_module.db_client = mock_postgres_client
+
+# Mock Elasticsearch (already done in the import section above, but keeping for reference)
+elasticsearch_client_mock = MagicMock()
+
+
+# Mock memory-related modules
+nexent_mock = MagicMock()
+sys.modules['nexent'] = nexent_mock
+sys.modules['nexent.core'] = MagicMock()
+sys.modules['nexent.core.agents'] = MagicMock()
+sys.modules['nexent.core.models'] = MagicMock()
+
+# Mock rerank_model module with proper class exports
+class MockBaseRerank:
+    pass
+
+class MockOpenAICompatibleRerank(MockBaseRerank):
+    def __init__(self, *args, **kwargs):
+        pass
+
+rerank_module = MagicMock()
+rerank_module.BaseRerank = MockBaseRerank
+rerank_module.OpenAICompatibleRerank = MockOpenAICompatibleRerank
+sys.modules['nexent.core.models.rerank_model'] = rerank_module
+# Don't mock agent_model yet, we need to import ToolConfig first
+sys.modules['nexent.memory'] = MagicMock()
+sys.modules['nexent.memory.memory_service'] = MagicMock()
 sys.modules['utils.str_utils'] = MagicMock()
 sys.modules['utils.str_utils'].convert_list_to_string = mock_convert_list_to_string
 sys.modules['utils.str_utils'].convert_string_to_list = lambda s: s.split(",") if s else []
diff --git a/test/backend/services/test_model_health_service.py b/test/backend/services/test_model_health_service.py
index 4cd08fc1f..5a81fa8b5 100644
--- a/test/backend/services/test_model_health_service.py
+++ b/test/backend/services/test_model_health_service.py
@@ -33,6 +33,19 @@ def __getattr__(cls, key):
 sys.modules['nexent.core.models'] = MockModule()
 sys.modules['nexent.core.models.embedding_model'] = MockModule()
 
+# Mock rerank_model module with proper class exports
+class MockBaseRerank:
+    pass
+
+class MockOpenAICompatibleRerank(MockBaseRerank):
+    def __init__(self, *args, **kwargs):
+        pass
+
+rerank_module = MockModule()
+rerank_module.BaseRerank = MockBaseRerank
+rerank_module.OpenAICompatibleRerank = MockOpenAICompatibleRerank
+sys.modules['nexent.core.models.rerank_model'] = rerank_module
+
 # Mock services packages
 sys.modules['services'] = MockModule()
 sys.modules['services.voice_service'] = MockModule()
@@ -292,16 +305,29 @@ async def test_perform_connectivity_check_stt():
 
 @pytest.mark.asyncio
 async def test_perform_connectivity_check_rerank():
-    # Execute
-    result = await _perform_connectivity_check(
-        "rerank-model",
-        "rerank",
-        "https://api.example.com",
-        "test-key",
-    )
+    # Setup - mock the rerank model
+    with mock.patch("backend.services.model_health_service.OpenAICompatibleRerank") as mock_rerank:
+        mock_rerank_instance = mock.MagicMock()
+        mock_rerank_instance.connectivity_check = mock.AsyncMock(return_value=True)
+        mock_rerank.return_value = mock_rerank_instance
+
+        # Execute
+        result = await _perform_connectivity_check(
+            "rerank-model",
+            "rerank",
+            "https://api.example.com",
+            "test-key",
+        )
 
-    # Assert
-    assert result is False
+        # Assert
+        assert result is True
+        mock_rerank.assert_called_once_with(
+            model_name="rerank-model",
+            base_url="https://api.example.com",
+            api_key="test-key",
+            ssl_verify=True
+        )
+        mock_rerank_instance.connectivity_check.assert_called_once()
 
 
 @pytest.mark.asyncio
diff --git a/test/backend/services/test_model_provider_service.py b/test/backend/services/test_model_provider_service.py
index 992025754..8d0f42614 100644
--- a/test/backend/services/test_model_provider_service.py
+++ b/test/backend/services/test_model_provider_service.py
@@ -657,6 +657,263 @@ async def test_prepare_model_dict_multi_embedding_defaults():
         assert result == expected
 
 
+@pytest.mark.asyncio
+async def test_prepare_model_dict_rerank_dashscope():
+    """Rerank models with DashScope provider should use special URL format."""
+    with mock.patch(
+        "backend.services.model_provider_service.split_repo_name",
+        return_value=("Alibaba-NLP", "gte-rerank-v2"),
+    ) as mock_split_repo, mock.patch(
+        "backend.services.model_provider_service.add_repo_to_name",
+        return_value="Alibaba-NLP/gte-rerank-v2",
+    ) as mock_add_repo_to_name, mock.patch(
+        "backend.services.model_provider_service.ModelRequest"
+    ) as mock_model_request, mock.patch(
+        "backend.services.model_provider_service.embedding_dimension_check",
+        new_callable=mock.AsyncMock,
+    ) as mock_emb_dim_check, mock.patch(
+        "backend.services.model_provider_service.ModelConnectStatusEnum"
+    ) as mock_enum:
+
+        mock_model_req_instance = mock.MagicMock()
+        dump_dict = {
+            "model_factory": "dashscope",
+            "model_name": "gte-rerank-v2",
+            "model_type": "rerank",
+            "api_key": "test-key",
+            "max_tokens": 0,
+            "display_name": "Alibaba-NLP/gte-rerank-v2",
+        }
+        mock_model_req_instance.model_dump.return_value = dump_dict
+        mock_model_request.return_value = mock_model_req_instance
+        mock_enum.NOT_DETECTED.value = "not_detected"
+
+        provider = "dashscope"
+        model = {
+            "id": "Alibaba-NLP/gte-rerank-v2",
+            "model_type": "rerank",
+        }
+        base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+        api_key = "test-key"
+
+        result = await prepare_model_dict(provider, model, base_url, api_key)
+
+        mock_split_repo.assert_called_once_with("Alibaba-NLP/gte-rerank-v2")
+        mock_add_repo_to_name.assert_called_once_with("Alibaba-NLP", "gte-rerank-v2")
+
+        # Embedding dimension check should NOT be called for rerank
+        mock_emb_dim_check.assert_not_called()
+
+        # Verify DashScope rerank URL format
+        assert "api/v1" in result["base_url"]
+        assert "services/rerank" in result["base_url"]
+        assert "text-rerank/text-rerank" in result["base_url"]
+        assert "rerank" in result["base_url"]
+
+
+@pytest.mark.asyncio
+async def test_prepare_model_dict_rerank_non_dashscope():
+    """Rerank models with non-DashScope provider should use standard /rerank URL."""
+    with mock.patch(
+        "backend.services.model_provider_service.split_repo_name",
+        return_value=("jina", "jina-rerank-v2-base"),
+    ) as mock_split_repo, mock.patch(
+        "backend.services.model_provider_service.add_repo_to_name",
+        return_value="jina/jina-rerank-v2-base",
+    ) as mock_add_repo_to_name, mock.patch(
+        "backend.services.model_provider_service.ModelRequest"
+    ) as mock_model_request, mock.patch(
+        "backend.services.model_provider_service.embedding_dimension_check",
+        new_callable=mock.AsyncMock,
+    ) as mock_emb_dim_check, mock.patch(
+        "backend.services.model_provider_service.ModelConnectStatusEnum"
+    ) as mock_enum:
+
+        mock_model_req_instance = mock.MagicMock()
+        dump_dict = {
+            "model_factory": "jina",
+            "model_name": "jina-rerank-v2-base",
+            "model_type": "rerank",
+            "api_key": "test-key",
+            "max_tokens": 0,
+            "display_name": "jina/jina-rerank-v2-base",
+        }
+        mock_model_req_instance.model_dump.return_value = dump_dict
+        mock_model_request.return_value = mock_model_req_instance
+        mock_enum.NOT_DETECTED.value = "not_detected"
+
+        provider = "jina"
+        model = {
+            "id": "jina/jina-rerank-v2-base",
+            "model_type": "rerank",
+        }
+        base_url = "https://api.jina.ai/v1"
+        api_key = "test-key"
+
+        result = await prepare_model_dict(provider, model, base_url, api_key)
+
+        mock_split_repo.assert_called_once_with("jina/jina-rerank-v2-base")
+        mock_add_repo_to_name.assert_called_once_with("jina", "jina-rerank-v2-base")
+
+        # Embedding dimension check should NOT be called for rerank
+        mock_emb_dim_check.assert_not_called()
+
+        # Verify non-DashScope rerank URL format
+        assert result["base_url"] == "https://api.jina.ai/v1/rerank"
+
+
+@pytest.mark.asyncio
+async def test_prepare_model_dict_rerank_with_compatible_mode_url():
+    """Rerank models with DashScope should handle compatible-mode/v1 URL replacement."""
+    with mock.patch(
+        "backend.services.model_provider_service.split_repo_name",
+        return_value=("Alibaba-NLP", "gte-rerank-v2"),
+    ) as mock_split_repo, mock.patch(
+        "backend.services.model_provider_service.add_repo_to_name",
+        return_value="Alibaba-NLP/gte-rerank-v2",
+    ) as mock_add_repo_to_name, mock.patch(
+        "backend.services.model_provider_service.ModelRequest"
+    ) as mock_model_request, mock.patch(
+        "backend.services.model_provider_service.ModelConnectStatusEnum"
+    ) as mock_enum:
+
+        mock_model_req_instance = mock.MagicMock()
+        dump_dict = {
+            "model_factory": "dashscope",
+            "model_name": "gte-rerank-v2",
+            "model_type": "rerank",
+            "api_key": "test-key",
+            "max_tokens": 0,
+            "display_name": "Alibaba-NLP/gte-rerank-v2",
+        }
+        mock_model_req_instance.model_dump.return_value = dump_dict
+        mock_model_request.return_value = mock_model_req_instance
+        mock_enum.NOT_DETECTED.value = "not_detected"
+
+        provider = "dashscope"
+        model = {
+            "id": "Alibaba-NLP/gte-rerank-v2",
+            "model_type": "rerank",
+        }
+        # Test with trailing slash and compatible-mode
+        base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1/"
+        api_key = "test-key"
+
+        result = await prepare_model_dict(provider, model, base_url, api_key)
+
+        # Verify the URL is properly processed
+        assert "compatible-mode/v1" not in result["base_url"]
+        assert "api/v1" in result["base_url"]
+        # Trailing slash should be stripped
+        assert not result["base_url"].endswith("//")
+
+
+@pytest.mark.asyncio
+async def test_prepare_model_dict_modelengine_non_embedding_ssl_verify():
+    """ModelEngine non-embedding models should have ssl_verify set to False."""
+    with mock.patch(
+        "backend.services.model_provider_service.split_repo_name",
+        return_value=("meta", "llama-3-8b"),
+    ) as mock_split_repo, mock.patch(
+        "backend.services.model_provider_service.add_repo_to_name",
+        return_value="meta/llama-3-8b",
+    ) as mock_add_repo_to_name, mock.patch(
+        "backend.services.model_provider_service.ModelRequest"
+    ) as mock_model_request, mock.patch(
+        "backend.services.model_provider_service.get_model_engine_raw_url",
+        return_value="https://modelengine.example.com/v1",
+    ) as mock_raw_url, mock.patch(
+        "backend.services.model_provider_service.embedding_dimension_check",
+        new_callable=mock.AsyncMock,
+    ) as mock_emb_dim_check, mock.patch(
+        "backend.services.model_provider_service.ModelConnectStatusEnum"
+    ) as mock_enum:
+
+        mock_model_req_instance = mock.MagicMock()
+        dump_dict = {
+            "model_factory": "modelengine",
+            "model_name": "llama-3-8b",
+            "model_type": "llm",
+            "api_key": "test-key",
+            "max_tokens": 4096,
+            "display_name": "meta/llama-3-8b",
+        }
+        mock_model_req_instance.model_dump.return_value = dump_dict
+        mock_model_request.return_value = mock_model_req_instance
+        mock_enum.NOT_DETECTED.value = "not_detected"
+
+        provider = "modelengine"
+        model = {
+            "id": "meta/llama-3-8b",
+            "model_type": "llm",
+            "max_tokens": 4096,
+            "base_url": "https://120.253.225.102:50001",
+        }
+        base_url = "https://modelengine.example.com/v1"
+        api_key = "test-key"
+
+        result = await prepare_model_dict(provider, model, base_url, api_key)
+
+        # Verify ssl_verify is set to False for ModelEngine
+        assert result["ssl_verify"] is False
+
+        # Verify the raw URL function was called
+        mock_raw_url.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_prepare_model_dict_modelengine_embedding_ssl_verify():
+    """ModelEngine embedding models should have ssl_verify set to False."""
+    with mock.patch(
+        "backend.services.model_provider_service.split_repo_name",
+        return_value=("openai", "text-embedding-3-small"),
+    ) as mock_split_repo, mock.patch(
+        "backend.services.model_provider_service.add_repo_to_name",
+        return_value="openai/text-embedding-3-small",
+    ) as mock_add_repo_to_name, mock.patch(
+        "backend.services.model_provider_service.ModelRequest"
+    ) as mock_model_request, mock.patch(
+        "backend.services.model_provider_service.get_model_engine_raw_url",
+        return_value="https://modelengine.example.com/v1",
+    ) as mock_raw_url, mock.patch(
+        "backend.services.model_provider_service.embedding_dimension_check",
+        new_callable=mock.AsyncMock,
+        return_value=1536,
+    ) as mock_emb_dim_check, mock.patch(
+        "backend.services.model_provider_service.ModelConnectStatusEnum"
+    ) as mock_enum:
+
+        mock_model_req_instance = mock.MagicMock()
+        dump_dict = {
+            "model_factory": "modelengine",
+            "model_name": "text-embedding-3-small",
+            "model_type": "embedding",
+            "api_key": "test-key",
+            "max_tokens": 8191,
+            "display_name": "openai/text-embedding-3-small",
+        }
+        mock_model_req_instance.model_dump.return_value = dump_dict
+        mock_model_request.return_value = mock_model_req_instance
+        mock_enum.NOT_DETECTED.value = "not_detected"
+
+        provider = "modelengine"
+        model = {
+            "id": "openai/text-embedding-3-small",
+            "model_type": "embedding",
+            "base_url": "https://120.253.225.102:50001",
+        }
+        base_url = "https://modelengine.example.com/v1"
+        api_key = "test-key"
+
+        result = await prepare_model_dict(provider, model, base_url, api_key)
+
+        # Verify ssl_verify is set to False for ModelEngine
+        assert result["ssl_verify"] is False
+
+        # Verify embedding dimension check was called
+        mock_emb_dim_check.assert_called_once()
+
+
 # ============================================================================
 # Test-cases for merge_existing_model_tokens
 # ============================================================================
diff --git a/test/backend/services/test_tool_configuration_service.py b/test/backend/services/test_tool_configuration_service.py
index 565e21f1c..24990bab9 100644
--- a/test/backend/services/test_tool_configuration_service.py
+++ b/test/backend/services/test_tool_configuration_service.py
@@ -151,6 +151,21 @@ class MockJinaEmbedding(MockBaseEmbedding):
 embedding_model_module.JinaEmbedding = MockJinaEmbedding
 sys.modules['nexent.core.models.embedding_model'] = embedding_model_module
 
+# Mock rerank_model module with proper class exports
+class MockBaseRerank:
+    """Mock BaseRerank class"""
+    pass
+
+class MockOpenAICompatibleRerank(MockBaseRerank):
+    """Mock OpenAICompatibleRerank class"""
+    def __init__(self, *args, **kwargs):
+        pass
+
+rerank_model_module = types.ModuleType('nexent.core.models.rerank_model')
+rerank_model_module.BaseRerank = MockBaseRerank
+rerank_model_module.OpenAICompatibleRerank = MockOpenAICompatibleRerank
+sys.modules['nexent.core.models.rerank_model'] = rerank_model_module
+
 # Provide model class used by file_management_service imports
 
 
@@ -1593,6 +1608,92 @@ def __init__(self):
         assert mock_build_tool_info.call_count == 2
 
 
+class TestBuildToolInfoFromLangchain:
+    """Test _build_tool_info_from_langchain function edge cases."""
+
+    def test_build_tool_info_from_langchain_with_empty_args(self):
+        """Test _build_tool_info_from_langchain when tool has no args."""
+        from backend.services.tool_configuration_service import _build_tool_info_from_langchain
+
+        # Create mock tool with no args attribute
+        mock_tool = MagicMock()
+        mock_tool.name = "test_tool"
+        mock_tool.description = "Test tool description"
+        mock_tool.args = {}
+        mock_tool.func = MagicMock()
+        mock_tool.func.__name__ = "test_func"
+
+        result = _build_tool_info_from_langchain(mock_tool)
+
+        assert result.name == "test_tool"
+        assert result.description == "Test tool description"
+
+    def test_build_tool_info_from_langchain_with_args_missing_description(self):
+        """Test _build_tool_info_from_langchain when args lacks description."""
+        from backend.services.tool_configuration_service import _build_tool_info_from_langchain
+
+        # Create mock tool with args missing description
+        mock_tool = MagicMock()
+        mock_tool.name = "test_tool"
+        mock_tool.description = "Test tool description"
+        mock_tool.args = {"param1": {"type": "string"}}  # Missing description
+        mock_tool.func = MagicMock()
+        mock_tool.func.__name__ = "test_func"
+
+        result = _build_tool_info_from_langchain(mock_tool)
+
+        # Verify description was added
+        import json
+        inputs = json.loads(result.inputs)
+        assert "description" in inputs["param1"]
+
+    def test_build_tool_info_from_langchain_with_invalid_signature(self):
+        """Test _build_tool_info_from_langchain when signature raises TypeError."""
+        from backend.services.tool_configuration_service import _build_tool_info_from_langchain
+
+        # Create a mock tool with a callable that will raise TypeError on signature
+        mock_func = lambda: None  # A simple callable
+        mock_tool = MagicMock()
+        mock_tool.name = "test_tool"
+        mock_tool.description = "Test tool description"
+        mock_tool.args = {}
+        mock_tool.func = mock_func
+
+        # Make inspect.signature raise TypeError
+        import inspect
+        with patch('backend.services.tool_configuration_service.inspect.signature', side_effect=TypeError("cannot inspect")):
+            result = _build_tool_info_from_langchain(mock_tool)
+
+        # Should fall back to string output type
+        assert result.output_type == "string"
+
+    def test_build_tool_info_from_langchain_with_invalid_return_annotation(self):
+        """Test _build_tool_info_from_langchain when return annotation raises ValueError."""
+        from backend.services.tool_configuration_service import _build_tool_info_from_langchain
+
+        # Create a mock tool with a callable that will raise ValueError on signature
+        mock_func = lambda: None
+        mock_tool = MagicMock()
+        mock_tool.name = "test_tool"
+        mock_tool.description = "Test tool description"
+        mock_tool.args = {}
+        mock_tool.func = mock_func
+
+        # Make inspect.signature raise ValueError for this specific callable
+        import inspect
+
+        def mock_signature(obj):
+            if obj == mock_func:
+                raise ValueError("Cannot get signature")
+            return inspect.signature(obj)
+
+        with patch('backend.services.tool_configuration_service.inspect.signature', side_effect=mock_signature):
+            result = _build_tool_info_from_langchain(mock_tool)
+
+        # Should fall back to string output type
+        assert result.output_type == "string"
+
+
 class TestLoadLastToolConfigImpl:
     """Test load_last_tool_config_impl function"""
 
@@ -2263,6 +2364,7 @@ def test_validate_local_tool_knowledge_base_search_success(self, mock_get_vector
             "index_names": ["default_index"],
             "vdb_core": mock_vdb_core,
             "embedding_model": "mock_embedding_model",
+            "rerank_model": None,
         }
         mock_tool_class.assert_called_once_with(**expected_params)
         mock_tool_instance.forward.assert_called_once_with(query="test query")
@@ -2406,6 +2508,7 @@ def test_validate_local_tool_knowledge_base_search_empty_knowledge_list(self, mo
             "index_names": [],
             "vdb_core": mock_vdb_core,
             "embedding_model": "mock_embedding_model",
+            "rerank_model": None,
         }
         mock_tool_class.assert_called_once_with(**expected_params)
         mock_tool_instance.forward.assert_called_once_with(query="test query")
@@ -2574,6 +2677,7 @@ def test_validate_local_tool_datamate_search_tool_success(self, mock_signature,
             "param": "config",
             # Filled from signature default
             "index_names": [],
+            "rerank_model": None,
         }
         mock_tool_class.assert_called_once_with(**expected_params)
         mock_tool_instance.forward.assert_called_once_with(query="test query")
@@ -2677,6 +2781,7 @@ def test_validate_local_tool_datamate_search_tool_empty_knowledge_list(self, moc
         expected_params = {
             "param": "config",
             "index_names": [],  # Empty list since no datamate sources
+            "rerank_model": None,
         }
         mock_tool_class.assert_called_once_with(**expected_params)
         mock_tool_instance.forward.assert_called_once_with(query="test query")
@@ -2717,6 +2822,7 @@ def test_validate_local_tool_datamate_search_tool_no_datamate_sources(self, mock
         expected_params = {
             "param": "config",
             "index_names": [],  # Empty list since no datamate sources
+            "rerank_model": None,
         }
         mock_tool_class.assert_called_once_with(**expected_params)
         mock_tool_instance.forward.assert_called_once_with(query="test query")
diff --git a/test/backend/services/test_vectordatabase_service.py b/test/backend/services/test_vectordatabase_service.py
index 48a411330..89df709e5 100644
--- a/test/backend/services/test_vectordatabase_service.py
+++ b/test/backend/services/test_vectordatabase_service.py
@@ -36,6 +36,11 @@ def _create_package_mock(name: str) -> MagicMock:
 openai_model_module.OpenAIModel = MagicMock
 sys.modules['nexent.core.models'] = openai_model_module
 sys.modules['nexent.core.models.embedding_model'] = MagicMock()
+# Mock rerank_model module with proper class exports
+rerank_model_module = ModuleType('nexent.core.models.rerank_model')
+rerank_model_module.OpenAICompatibleRerank = MagicMock()
+rerank_model_module.BaseRerank = MagicMock()
+sys.modules['nexent.core.models.rerank_model'] = rerank_model_module
 sys.modules['nexent.core.models.stt_model'] = MagicMock()
 sys.modules['nexent.core.nlp'] = _create_package_mock('nexent.core.nlp')
 sys.modules['nexent.core.nlp.tokenizer'] = MagicMock()
@@ -172,6 +177,13 @@ def setUp(self):
         self.mock_embedding.model = "test-model"
         self.mock_get_embedding.return_value = self.mock_embedding
 
+        # Patch get_rerank_model for all tests
+        self.get_rerank_model_patcher = patch(
+            'backend.services.vectordatabase_service.get_rerank_model')
+        self.mock_get_rerank = self.get_rerank_model_patcher.start()
+        self.mock_rerank = MagicMock()
+        self.mock_get_rerank.return_value = self.mock_rerank
+
         ElasticSearchService.accurate_search = staticmethod(
             _accurate_search_impl)
         ElasticSearchService.semantic_search = staticmethod(
@@ -180,6 +192,7 @@ def setUp(self):
     def tearDown(self):
         """Clean up resources after each test."""
         self.get_embedding_model_patcher.stop()
+        self.get_rerank_model_patcher.stop()
         if hasattr(ElasticSearchService, 'accurate_search'):
             del ElasticSearchService.accurate_search
         if hasattr(ElasticSearchService, 'semantic_search'):
@@ -4160,8 +4173,15 @@ def setUp(self):
         self.mock_embedding.model = "test-model"
         self.mock_get_embedding.return_value = self.mock_embedding
 
+        self.get_rerank_model_patcher = patch(
+            'backend.services.vectordatabase_service.get_rerank_model')
+        self.mock_get_rerank = self.get_rerank_model_patcher.start()
+        self.mock_rerank = MagicMock()
+        self.mock_get_rerank.return_value = self.mock_rerank
+
     def tearDown(self):
         self.get_embedding_model_patcher.stop()
+        self.get_rerank_model_patcher.stop()
 
     def test_rethrow_or_plain_rethrows_json_error_code(self):
         """_rethrow_or_plain should re-raise JSON payload when error_code present."""
@@ -4746,6 +4766,269 @@ async def run_test():
             messages = asyncio.run(run_test())
             self.assertTrue(any("error" in msg for msg in messages))
 
+    # Tests for get_rerank_model function
+    @patch('backend.services.vectordatabase_service.get_model_records')
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_with_specific_model_name_found(
+        self, mock_get_model_name, mock_tenant_config, mock_get_records
+    ):
+        """Test get_rerank_model when specific model name is provided and found."""
+        # Setup
+        mock_get_records.return_value = [
+            {
+                "model_name": "gte-rerank-v2",
+                "model_repo": "Alibaba-NLP",
+                "base_url": "https://api.example.com",
+                "api_key": "test-key",
+                "ssl_verify": True
+            }
+        ]
+        mock_get_model_name.return_value = "gte-rerank-v2"
+
+        mock_config = {"model_type": "embedding"}
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                mock_rerank_instance = MagicMock()
+                mock_rerank_class.return_value = mock_rerank_instance
+
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123", "Alibaba-NLP/gte-rerank-v2")
+
+                # Assert
+                self.assertIsNotNone(result)
+                mock_get_records.assert_called_once_with({"model_type": "rerank"}, "tenant-123")
+                mock_rerank_class.assert_called_once_with(
+                    model_name="gte-rerank-v2",
+                    base_url="https://api.example.com",
+                    api_key="test-key",
+                    ssl_verify=True
+                )
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.get_model_records')
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_with_specific_model_name_not_found(
+        self, mock_get_model_name, mock_tenant_config, mock_get_records
+    ):
+        """Test get_rerank_model when specific model name is not found, falls back to default."""
+        # Setup
+        mock_get_records.return_value = [
+            {
+                "model_name": "other-model",
+                "model_repo": "some-repo",
+                "base_url": "https://other.api.com",
+                "api_key": "other-key",
+                "ssl_verify": False
+            }
+        ]
+        mock_get_model_name.return_value = "other-model"
+
+        mock_config = {
+            "model_type": "rerank",
+            "model_name": "default-rerank",
+            "base_url": "https://default.api.com",
+            "api_key": "default-key",
+            "ssl_verify": True
+        }
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                mock_rerank_instance = MagicMock()
+                mock_rerank_class.return_value = mock_rerank_instance
+
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123", "nonexistent-model")
+
+                # Assert
+                self.assertIsNotNone(result)
+                mock_get_records.assert_called_once()
+                mock_tenant_config.get_model_config.assert_called_with(
+                    key="RERANK_ID", tenant_id="tenant-123"
+                )
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.get_model_records')
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_with_specific_model_name_exception(
+        self, mock_get_model_name, mock_tenant_config, mock_get_records
+    ):
+        """Test get_rerank_model when get_model_records throws an exception."""
+        # Setup
+        mock_get_records.side_effect = Exception("Database error")
+
+        mock_config = {
+            "model_type": "rerank",
+            "model_name": "default-rerank",
+            "base_url": "https://default.api.com",
+            "api_key": "default-key",
+            "ssl_verify": True
+        }
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                mock_rerank_instance = MagicMock()
+                mock_rerank_class.return_value = mock_rerank_instance
+
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123", "some-model")
+
+                # Assert
+                # Should fall back to default model when exception occurs
+                self.assertIsNotNone(result)
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_default_rerank_type(self, mock_get_model_name, mock_tenant_config):
+        """Test get_rerank_model with default rerank model when model_type is rerank."""
+        # Setup
+        mock_get_model_name.return_value = "default-rerank"
+
+        mock_config = {
+            "model_type": "rerank",
+            "model_name": "default-rerank",
+            "base_url": "https://api.dashscope.aliyuncs.com",
+            "api_key": "secret-key",
+            "ssl_verify": True
+        }
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                mock_rerank_instance = MagicMock()
+                mock_rerank_class.return_value = mock_rerank_instance
+
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123")
+
+                # Assert
+                self.assertIsNotNone(result)
+                mock_tenant_config.get_model_config.assert_called_once_with(
+                    key="RERANK_ID", tenant_id="tenant-123"
+                )
+                mock_rerank_class.assert_called_once_with(
+                    model_name="default-rerank",
+                    base_url="https://api.dashscope.aliyuncs.com",
+                    api_key="secret-key",
+                    ssl_verify=True
+                )
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_non_rerank_type_returns_none(self, mock_get_model_name, mock_tenant_config):
+        """Test get_rerank_model returns None when model_type is not rerank."""
+        # Setup
+        mock_config = {
+            "model_type": "embedding",
+            "model_name": "embedding-model",
+            "base_url": "https://api.example.com",
+            "api_key": "key"
+        }
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123")
+
+                # Assert
+                self.assertIsNone(result)
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_empty_config(self, mock_get_model_name, mock_tenant_config):
+        """Test get_rerank_model returns None when model config is empty."""
+        # Setup
+        mock_tenant_config.get_model_config.return_value = {}
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123")
+
+                # Assert
+                self.assertIsNone(result)
+        finally:
+            self.get_rerank_model_patcher.start()
+
+    @patch('backend.services.vectordatabase_service.get_model_records')
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_name_from_config')
+    def test_get_rerank_model_with_model_name_no_repo(
+        self, mock_get_model_name, mock_tenant_config, mock_get_records
+    ):
+        """Test get_rerank_model when model has no model_repo."""
+        # Setup
+        mock_get_records.return_value = [
+            {
+                "model_name": "gte-rerank-v2",
+                "model_repo": None,
+                "base_url": "https://api.example.com",
+                "api_key": "test-key",
+                "ssl_verify": True
+            }
+        ]
+        mock_get_model_name.return_value = "gte-rerank-v2"
+
+        mock_config = {"model_type": "embedding"}
+        mock_tenant_config.get_model_config.return_value = mock_config
+
+        # Stop the mock from setUp to test the real function
+        self.get_rerank_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.OpenAICompatibleRerank') as mock_rerank_class:
+                mock_rerank_instance = MagicMock()
+                mock_rerank_class.return_value = mock_rerank_instance
+
+                # Execute
+                from backend.services.vectordatabase_service import get_rerank_model
+                result = get_rerank_model("tenant-123", "gte-rerank-v2")
+
+                # Assert
+                self.assertIsNotNone(result)
+                mock_rerank_class.assert_called_once()
+        finally:
+            self.get_rerank_model_patcher.start()
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/backend/utils/test_prompt_template_utils.py b/test/backend/utils/test_prompt_template_utils.py
index e657b3a06..c89c41f42 100644
--- a/test/backend/utils/test_prompt_template_utils.py
+++ b/test/backend/utils/test_prompt_template_utils.py
@@ -1,7 +1,15 @@
 import pytest
 from unittest.mock import mock_open
 
-from utils.prompt_template_utils import get_agent_prompt_template, get_prompt_generate_prompt_template
+from utils.prompt_template_utils import (
+    get_agent_prompt_template,
+    get_prompt_generate_prompt_template,
+    get_generate_title_prompt_template,
+    get_document_summary_prompt_template,
+    get_cluster_summary_reduce_prompt_template,
+    get_skill_creation_simple_prompt_template,
+    get_prompt_template,
+)
 
 
 class TestPromptTemplateUtils:
@@ -127,5 +135,323 @@ def test_get_prompt_generate_prompt_template_default_language(self, mocker):
         assert result == {"test": "data"}
 
 
-if __name__ == '__main__':
-    pytest.main()
+class TestGetPromptTemplate:
+    """Test cases for get_prompt_template function"""
+
+    def test_get_prompt_template_unsupported_type(self, mocker):
+        """Test get_prompt_template with unsupported template type raises ValueError"""
+        with pytest.raises(ValueError) as excinfo:
+            get_prompt_template(template_type='unsupported_type', language='zh')
+
+        assert "Unsupported template type" in str(excinfo.value)
+
+    def test_get_prompt_template_file_not_found(self, mocker):
+        """Test get_prompt_template raises FileNotFoundError when file is missing"""
+        mocker.patch('builtins.open', side_effect=FileNotFoundError("File not found"))
+
+        with pytest.raises(FileNotFoundError):
+            get_prompt_template(template_type='prompt_generate', language='zh')
+
+    def test_get_prompt_template_prompt_generate_zh(self, mocker):
+        """Test get_prompt_template for prompt_generate in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "test"'))
+
+        mock_yaml_load.return_value = {"system": "test"}
+        result = get_prompt_template(template_type='prompt_generate', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/prompt_generate_zh.yaml' in call_args[0].replace('\\', '/')
+        mock_yaml_load.assert_called_once()
+        assert result == {"system": "test"}
+
+    def test_get_prompt_template_prompt_generate_en(self, mocker):
+        """Test get_prompt_template for prompt_generate in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "test"'))
+
+        mock_yaml_load.return_value = {"system": "test"}
+        result = get_prompt_template(template_type='prompt_generate', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/prompt_generate_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "test"}
+
+    def test_get_prompt_template_agent_manager_zh(self, mocker):
+        """Test get_prompt_template for agent with is_manager=True in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "manager"'))
+
+        mock_yaml_load.return_value = {"system": "manager"}
+        result = get_prompt_template(template_type='agent', language='zh', is_manager=True)
+
+        call_args = mock_file.call_args[0]
+        assert 'manager_system_prompt_template_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "manager"}
+
+    def test_get_prompt_template_agent_managed_zh(self, mocker):
+        """Test get_prompt_template for agent with is_manager=False in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system: "managed"'))
+
+        mock_yaml_load.return_value = {"system": "managed"}
+        result = get_prompt_template(template_type='agent', language='zh', is_manager=False)
+
+        call_args = mock_file.call_args[0]
+        assert 'managed_system_prompt_template_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system": "managed"}
+
+    def test_get_prompt_template_generate_title_zh(self, mocker):
+        """Test get_prompt_template for generate_title in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='title: "test"'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_prompt_template(template_type='generate_title', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_prompt_template_generate_title_en(self, mocker):
+        """Test get_prompt_template for generate_title in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='title: "test"'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_prompt_template(template_type='generate_title', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_prompt_template_document_summary_zh(self, mocker):
+        """Test get_prompt_template for document_summary in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='summary: "test"'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_prompt_template(template_type='document_summary', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_prompt_template_document_summary_en(self, mocker):
+        """Test get_prompt_template for document_summary in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='summary: "test"'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_prompt_template(template_type='document_summary', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_prompt_template_cluster_summary_reduce_zh(self, mocker):
+        """Test get_prompt_template for cluster_summary_reduce in Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='reduce: "test"'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_prompt_template(template_type='cluster_summary_reduce', language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_prompt_template_cluster_summary_reduce_en(self, mocker):
+        """Test get_prompt_template for cluster_summary_reduce in English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='reduce: "test"'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_prompt_template(template_type='cluster_summary_reduce', language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+
+class TestWrapperFunctions:
+    """Test cases for wrapper functions"""
+
+    def test_get_generate_title_prompt_template_zh(self, mocker):
+        """Test get_generate_title_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_generate_title_prompt_template_en(self, mocker):
+        """Test get_generate_title_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_generate_title_prompt_template_default(self, mocker):
+        """Test get_generate_title_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"title": "test"}'))
+
+        mock_yaml_load.return_value = {"title": "test"}
+        result = get_generate_title_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'utils/generate_title_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"title": "test"}
+
+    def test_get_document_summary_prompt_template_zh(self, mocker):
+        """Test get_document_summary_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_document_summary_prompt_template_en(self, mocker):
+        """Test get_document_summary_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_document_summary_prompt_template_default(self, mocker):
+        """Test get_document_summary_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"summary": "test"}'))
+
+        mock_yaml_load.return_value = {"summary": "test"}
+        result = get_document_summary_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'document_summary_agent_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"summary": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_zh(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_en(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+    def test_get_cluster_summary_reduce_prompt_template_default(self, mocker):
+        """Test get_cluster_summary_reduce_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='{"reduce": "test"}'))
+
+        mock_yaml_load.return_value = {"reduce": "test"}
+        result = get_cluster_summary_reduce_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'cluster_summary_reduce_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"reduce": "test"}
+
+
+class TestSkillCreationSimplePromptTemplate:
+    """Test cases for get_skill_creation_simple_prompt_template function"""
+
+    def test_get_skill_creation_simple_prompt_template_zh(self, mocker):
+        """Test get_skill_creation_simple_prompt_template for Chinese"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='zh')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        mock_yaml_load.assert_called_once()
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_en(self, mocker):
+        """Test get_skill_creation_simple_prompt_template for English"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='en')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_en.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_default(self, mocker):
+        """Test get_skill_creation_simple_prompt_template with default language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template()
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_fallback(self, mocker):
+        """Test get_skill_creation_simple_prompt_template falls back to Chinese for unknown language"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='system_prompt: "sys"\nuser_prompt: "user"'))
+
+        mock_yaml_load.return_value = {"system_prompt": "sys", "user_prompt": "user"}
+        result = get_skill_creation_simple_prompt_template(language='unknown')
+
+        call_args = mock_file.call_args[0]
+        assert 'skill_creation_simple_zh.yaml' in call_args[0].replace('\\', '/')
+        assert result == {"system_prompt": "sys", "user_prompt": "user"}
+
+    def test_get_skill_creation_simple_prompt_template_missing_keys(self, mocker):
+        """Test get_skill_creation_simple_prompt_template handles missing keys in YAML"""
+        mock_yaml_load = mocker.patch('yaml.safe_load')
+        mock_file = mocker.patch('builtins.open', mock_open(read_data='other: "data"'))
+
+        mock_yaml_load.return_value = {"other": "data"}
+        result = get_skill_creation_simple_prompt_template(language='zh')
+
+        # Missing keys should default to empty strings
+        assert result == {"system_prompt": "", "user_prompt": ""}
+
+    def test_get_skill_creation_simple_prompt_template_file_not_found(self, mocker):
+        """Test get_skill_creation_simple_prompt_template raises FileNotFoundError when file is missing"""
+        mocker.patch('builtins.open', side_effect=FileNotFoundError("File not found"))
+
+        with pytest.raises(FileNotFoundError):
+            get_skill_creation_simple_prompt_template(language='zh')
diff --git a/test/sdk/core/models/test_rerank_model.py b/test/sdk/core/models/test_rerank_model.py
new file mode 100644
index 000000000..8a2d68cfb
--- /dev/null
+++ b/test/sdk/core/models/test_rerank_model.py
@@ -0,0 +1,593 @@
+import asyncio
+import pytest
+import sys
+import os
+from unittest.mock import MagicMock, patch
+
+# Add SDK to path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+sdk_dir = os.path.abspath(os.path.join(current_dir, "../../../sdk"))
+sys.path.insert(0, sdk_dir)
+
+
+class TestOpenAICompatibleRerank:
+    """Test cases for OpenAICompatibleRerank class."""
+
+    def test_init_with_all_params(self):
+        """Test initialization with all parameters."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key-123",
+            ssl_verify=True
+        )
+
+        assert rerank.model == "gte-rerank-v1"
+        assert rerank.api_url == "https://api.example.com/v1/rerank"
+        assert rerank.api_key == "test-key-123"
+        assert rerank.ssl_verify is True
+        assert rerank.headers["Authorization"] == "Bearer test-key-123"
+
+    def test_init_with_default_ssl_verify(self):
+        """Test initialization with default ssl_verify."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        assert rerank.ssl_verify is True
+
+    def test_prepare_request_dashscope_format(self):
+        """Test request preparation for DashScope API format."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="qwen3-rerank",
+            base_url="https://dashscope.aliyuncs.com/api/v1/services/rerank/text-rerank",
+            api_key="test-key"
+        )
+
+        result = rerank._prepare_request(
+            query="test query",
+            documents=["doc1", "doc2", "doc3"],
+            top_n=3
+        )
+
+        assert result["model"] == "qwen3-rerank"
+        assert result["input"]["query"] == "test query"
+        assert result["input"]["documents"] == ["doc1", "doc2", "doc3"]
+        assert result["parameters"]["top_n"] == 3
+
+    def test_prepare_request_openai_format(self):
+        """Test request preparation for OpenAI-compatible API format."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.openai.com/v1/rerank",
+            api_key="test-key"
+        )
+
+        result = rerank._prepare_request(
+            query="test query",
+            documents=["doc1", "doc2"],
+            top_n=2
+        )
+
+        assert result["model"] == "gte-rerank-v1"
+        assert result["query"] == "test query"
+        assert result["documents"] == ["doc1", "doc2"]
+        assert result["top_n"] == 2
+
+    def test_prepare_request_with_default_top_n(self):
+        """Test request preparation with default top_n (uses document count)."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key"
+        )
+
+        result = rerank._prepare_request(
+            query="query",
+            documents=["a", "b", "c", "d"]
+        )
+
+        assert result["top_n"] == 4
+
+    @patch('nexent.core.models.rerank_model.requests.post')
+    def test_rerank_openai_format_success(self, mock_post):
+        """Test successful rerank with OpenAI format response."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "results": [
+                {"index": 0, "relevance_score": 0.95, "document": "doc1"},
+                {"index": 2, "relevance_score": 0.85, "document": "doc3"},
+                {"index": 1, "relevance_score": 0.75, "document": "doc2"},
+            ]
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key"
+        )
+
+        results = rerank.rerank(
+            query="test query",
+            documents=["doc1", "doc2", "doc3"],
+            top_n=3
+        )
+
+        assert len(results) == 3
+        assert results[0]["index"] == 0
+        assert results[0]["relevance_score"] == 0.95
+        assert results[0]["document"] == "doc1"
+
+    @patch('nexent.core.models.rerank_model.requests.post')
+    def test_rerank_dashscope_format_success(self, mock_post):
+        """Test successful rerank with DashScope format response."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "output": {
+                "results": [
+                    {"index": 1, "relevance_score": 0.9, "document": {"text": "doc2"}},
+                    {"index": 0, "relevance_score": 0.8, "document": {"text": "doc1"}},
+                ]
+            }
+        }
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        rerank = OpenAICompatibleRerank(
+            model_name="qwen3-rerank",
+            base_url="https://dashscope.aliyuncs.com/api/v1/services/rerank",
+            api_key="test-key"
+        )
+
+        results = rerank.rerank(
+            query="test query",
+            documents=["doc1", "doc2"]
+        )
+
+        assert len(results) == 2
+        assert results[0]["index"] == 1
+        assert results[0]["document"] == "doc2"
+
+    def test_rerank_empty_documents(self):
+        """Test rerank with empty documents list."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        results = rerank.rerank(query="query", documents=[])
+
+        assert results == []
+
+    @patch('nexent.core.models.rerank_model.requests.post')
+    def test_rerank_timeout_retry(self, mock_post):
+        """Test rerank with timeout and retry logic."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        # First two calls timeout, third succeeds
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"results": []}
+        mock_response.raise_for_status = MagicMock()
+
+        mock_post.side_effect = [
+            requests.exceptions.Timeout(),
+            requests.exceptions.Timeout(),
+            mock_response
+        ]
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        # Should eventually succeed after retries
+        results = rerank.rerank(query="test", documents=["doc1"])
+        assert results == []
+        assert mock_post.call_count == 3
+
+    @patch('nexent.core.models.rerank_model.requests.post')
+    def test_rerank_request_exception(self, mock_post):
+        """Test rerank with request exception."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_post.side_effect = requests.exceptions.RequestException("Connection error")
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        with pytest.raises(requests.exceptions.RequestException):
+            rerank.rerank(query="test", documents=["doc1"])
+
+    @pytest.mark.asyncio
+    @patch('nexent.core.models.rerank_model.requests.post')
+    async def test_connectivity_check_success(self, mock_post):
+        """Test connectivity check with successful connection."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"results": [{"index": 0, "relevance_score": 0.9, "document": "test"}]}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    @patch('nexent.core.models.rerank_model.requests.post')
+    async def test_connectivity_check_timeout(self, mock_post):
+        """Test connectivity check with timeout."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_post.side_effect = requests.exceptions.Timeout()
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch('nexent.core.models.rerank_model.requests.post')
+    async def test_connectivity_check_connection_error(self, mock_post):
+        """Test connectivity check with connection error."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_post.side_effect = requests.exceptions.ConnectionError()
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch('nexent.core.models.rerank_model.requests.post')
+    async def test_connectivity_check_generic_error(self, mock_post):
+        """Test connectivity check with generic error."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        mock_post.side_effect = Exception("Unknown error")
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch('nexent.core.models.rerank_model.requests.post')
+    async def test_rerank_async(self, mock_post):
+        """Test async rerank method."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"results": [{"index": 0, "relevance_score": 0.9, "document": "test"}]}
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="test-model",
+            base_url="https://api.example.com",
+            api_key="test-key"
+        )
+
+        results = await rerank.rerank_async(
+            query="test query",
+            documents=["doc1", "doc2"]
+        )
+
+        assert len(results) == 1
+        assert results[0]["index"] == 0
+
+
+class TestJinaRerank:
+    """Test cases for JinaRerank class."""
+
+    def test_init(self):
+        """Test JinaRerank initialization."""
+        from nexent.core.models.rerank_model import JinaRerank
+
+        rerank = JinaRerank(
+            api_key="jina-api-key",
+            model_name="jina-rerank-v2-base",
+            base_url="https://api.jina.ai/v1/rerank"
+        )
+
+        assert rerank.model == "jina-rerank-v2-base"
+        assert rerank.api_url == "https://api.jina.ai/v1/rerank"
+        assert rerank.api_key == "jina-api-key"
+
+    def test_init_with_defaults(self):
+        """Test JinaRerank initialization with default values."""
+        from nexent.core.models.rerank_model import JinaRerank
+
+        rerank = JinaRerank(api_key="test-key")
+
+        assert rerank.model == "jina-rerank-v2-base"
+        assert rerank.api_url == "https://api.jina.ai/v1/rerank"
+
+
+class TestCohereRerank:
+    """Test cases for CohereRerank class."""
+
+    def test_init(self):
+        """Test CohereRerank initialization."""
+        from nexent.core.models.rerank_model import CohereRerank
+
+        rerank = CohereRerank(
+            api_key="cohere-api-key",
+            model_name="rerank-multilingual-v3.0",
+            base_url="https://api.cohere.ai/v1/rerank"
+        )
+
+        assert rerank.model == "rerank-multilingual-v3.0"
+        assert rerank.api_url == "https://api.cohere.ai/v1/rerank"
+        assert rerank.api_key == "cohere-api-key"
+
+    def test_init_with_defaults(self):
+        """Test CohereRerank initialization with default values."""
+        from nexent.core.models.rerank_model import CohereRerank
+
+        rerank = CohereRerank(api_key="test-key")
+
+        assert rerank.model == "rerank-multilingual-v3.0"
+        assert rerank.api_url == "https://api.cohere.ai/v1/rerank"
+
+
+class TestBaseRerank:
+    """Test cases for BaseRerank abstract class."""
+
+    def test_base_class_is_abstract(self):
+        """Test that BaseRerank cannot be instantiated directly."""
+        from nexent.core.models.rerank_model import BaseRerank
+
+        with pytest.raises(TypeError):
+            BaseRerank()
+
+
+class TestOpenAICompatibleRerankEdgeCases:
+    """Additional edge case tests for OpenAICompatibleRerank."""
+
+    def test_prepare_request_openai_format(self):
+        """Test _prepare_request with OpenAI-compatible format."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        result = rerank._prepare_request(
+            query="test query",
+            documents=["doc1", "doc2", "doc3"],
+            top_n=3
+        )
+
+        assert result["model"] == "gte-rerank-v1"
+        assert result["query"] == "test query"
+        assert result["documents"] == ["doc1", "doc2", "doc3"]
+        assert result["top_n"] == 3
+
+    def test_prepare_request_dashscope_format(self):
+        """Test _prepare_request with DashScope format."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="qwen3-rerank",
+            base_url="https://dashscope.aliyuncs.com/api/v1",
+            api_key="test-key",
+        )
+
+        result = rerank._prepare_request(
+            query="test query",
+            documents=["doc1", "doc2"],
+            top_n=2
+        )
+
+        # DashScope format has nested input
+        assert "input" in result
+        assert result["input"]["query"] == "test query"
+        assert result["input"]["documents"] == ["doc1", "doc2"]
+        assert "parameters" in result
+        assert result["parameters"]["top_n"] == 2
+
+    def test_prepare_request_empty_top_n(self):
+        """Test _prepare_request when top_n is None (defaults to len of documents)."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        result = rerank._prepare_request(
+            query="test query",
+            documents=["doc1", "doc2", "doc3"],
+            top_n=None
+        )
+
+        # Should default to len of documents
+        assert result["top_n"] == 3
+
+    def test_rerank_empty_documents(self):
+        """Test rerank returns empty list when documents is empty."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        result = rerank.rerank(query="test", documents=[], top_n=1)
+
+        assert result == []
+
+    def test_rerank_response_with_output_results(self):
+        """Test rerank handles DashScope response format with output.results."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+        import requests
+
+        rerank = OpenAICompatibleRerank(
+            model_name="qwen3-rerank",
+            base_url="https://dashscope.aliyuncs.com/api/v1/services/rerank",
+            api_key="test-key",
+        )
+
+        # Mock the response to simulate DashScope format
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "output": {
+                "results": [
+                    {"index": 0, "relevance_score": 0.95, "document": {"text": "doc1"}},
+                    {"index": 1, "relevance_score": 0.85, "document": {"text": "doc2"}},
+                ]
+            }
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        with patch.object(requests, 'post', return_value=mock_response):
+            result = rerank.rerank(
+                query="test query",
+                documents=["doc1", "doc2"],
+                top_n=2
+            )
+
+        assert len(result) == 2
+        assert result[0]["index"] == 0
+        assert result[0]["relevance_score"] == 0.95
+
+    def test_rerank_response_with_string_document(self):
+        """Test rerank handles response where document is a string (not dict)."""
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+        import requests
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        # Mock the response where document is a string
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "results": [
+                {"index": 0, "relevance_score": 0.95, "document": "doc1_text"},
+                {"index": 1, "relevance_score": 0.85, "document": "doc2_text"},
+            ]
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        with patch.object(requests, 'post', return_value=mock_response):
+            result = rerank.rerank(
+                query="test query",
+                documents=["doc1", "doc2"],
+                top_n=2
+            )
+
+        assert len(result) == 2
+        assert result[0]["document"] == "doc1_text"
+
+    @pytest.mark.asyncio
+    async def test_connectivity_check_timeout(self):
+        """Test connectivity_check handles timeout."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        # Mock a timeout exception
+        with patch.object(requests, 'post', side_effect=requests.exceptions.Timeout("timeout")):
+            result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_connectivity_check_connection_error(self):
+        """Test connectivity_check handles connection error."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        # Mock a connection error
+        with patch.object(requests, 'post', side_effect=requests.exceptions.ConnectionError("connection error")):
+            result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_connectivity_check_generic_exception(self):
+        """Test connectivity_check handles generic exception."""
+        import requests
+        from nexent.core.models.rerank_model import OpenAICompatibleRerank
+
+        rerank = OpenAICompatibleRerank(
+            model_name="gte-rerank-v1",
+            base_url="https://api.example.com/v1/rerank",
+            api_key="test-key",
+        )
+
+        # Mock a generic exception
+        with patch.object(requests, 'post', side_effect=Exception("generic error")):
+            result = await rerank.connectivity_check(timeout=5.0)
+
+        assert result is False
diff --git a/test/sdk/core/tools/test_datamate_search_tool.py b/test/sdk/core/tools/test_datamate_search_tool.py
index 855bcf294..4390c627b 100644
--- a/test/sdk/core/tools/test_datamate_search_tool.py
+++ b/test/sdk/core/tools/test_datamate_search_tool.py
@@ -23,6 +23,7 @@ def datamate_tool(mock_observer: MessageObserver) -> DataMateSearchTool:
         index_names=["kb1"],
         top_k=2,
         threshold=0.5,
+        rerank=False,
     )
     return tool
 
@@ -204,7 +205,7 @@ def test_forward_success_with_observer_zh(self, datamate_tool: DataMateSearchToo
 
     def test_forward_no_observer(self, mocker: MockFixture):
         tool = DataMateSearchTool(
-            server_url="http://127.0.0.1:8080", observer=None, index_names=["kb1"])
+            server_url="http://127.0.0.1:8080", observer=None, index_names=["kb1"], rerank=False)
 
         # Mock the hybrid_search method to return search results
         mock_hybrid_search = mocker.patch.object(
@@ -263,6 +264,7 @@ def test_forward_with_default_index_names(self, datamate_tool: DataMateSearchToo
         datamate_tool.index_names = ["default_kb1", "default_kb2"]
         datamate_tool.top_k = 3
         datamate_tool.threshold = 0.2
+        datamate_tool.rerank = False  # Ensure rerank is disabled
 
         # Mock the hybrid_search method to return results for each knowledge base
         mock_hybrid_search = mocker.patch.object(
@@ -303,6 +305,7 @@ def test_forward_multiple_knowledge_bases(self, datamate_tool: DataMateSearchToo
         datamate_tool.index_names = ["kb1", "kb2"]
         datamate_tool.top_k = 3
         datamate_tool.threshold = 0.2
+        datamate_tool.rerank = False  # Ensure rerank is disabled
 
         # Mock the hybrid_search method to return results from multiple KBs
         mock_hybrid_search = mocker.patch.object(
@@ -345,6 +348,7 @@ def test_forward_with_custom_parameters(self, datamate_tool: DataMateSearchTool,
         datamate_tool.index_names = ["kb1"]
         datamate_tool.top_k = 5
         datamate_tool.threshold = 0.8
+        datamate_tool.rerank = False  # Ensure rerank is disabled
 
         # Mock the hybrid_search method
         mock_hybrid_search = mocker.patch.object(
@@ -526,3 +530,223 @@ def test_url_invalid_format(self, mock_observer: MessageObserver):
 
         with pytest.raises(ValueError, match="Invalid server_url format"):
             DataMateSearchTool(server_url="http://", observer=mock_observer)
+
+
+class TestDataMateSearchToolRerank:
+    """Tests for DataMateSearchTool rerank functionality."""
+
+    def test_init_with_rerank_params(self, mock_observer: MessageObserver):
+        """Test initialization with rerank parameters."""
+        tool = DataMateSearchTool(
+            server_url="http://127.0.0.1:8080",
+            index_names=["kb1"],
+            top_k=3,
+            threshold=0.5,
+            rerank=True,
+            rerank_model_name="gte-rerank-v2",
+            rerank_model=None,
+            observer=mock_observer,
+        )
+
+             # When explicit values are passed, smolagents Tool handles them correctly
+        assert tool.rerank is True
+        assert tool.rerank_model_name == "gte-rerank-v2"
+        assert tool.rerank_model is None
+
+    def test_init_without_rerank_params(self, mock_observer: MessageObserver):
+        """Test initialization without rerank parameters (defaults)."""
+        tool = DataMateSearchTool(
+            server_url="http://127.0.0.1:8080",
+            index_names=["kb1"],
+            observer=mock_observer,
+        )
+
+        # smolagents Tool doesn't properly handle Field defaults, so we check FieldInfo.default
+        try:
+            from pydantic import FieldInfo
+        except ImportError:
+            from pydantic.fields import FieldInfo
+        assert isinstance(tool.rerank, FieldInfo)
+        assert tool.rerank.default is False
+        assert tool.rerank_model_name.default == ""
+        assert tool.rerank_model.default is None
+
+    def test_forward_with_rerank_enabled(self, mock_observer: MessageObserver, mocker: MockFixture):
+        """Test forward method when rerank is enabled and model is provided."""
+        # Create tool first
+        mock_rerank_model = MagicMock()
+        mock_rerank_model.rerank.return_value = [
+            {"index": 1, "relevance_score": 0.95, "document": "content 2"},
+            {"index": 0, "relevance_score": 0.85, "document": "content 1"},
+        ]
+
+        tool = DataMateSearchTool(
+            server_url="http://127.0.0.1:8080",
+            index_names=["kb1"],
+            top_k=3,
+            rerank=True,
+            rerank_model_name="gte-rerank-v2",
+            rerank_model=mock_rerank_model,
+            observer=mock_observer,
+        )
+
+        # Mock hybrid_search method on the tool instance
+        mocker.patch.object(
+            tool.datamate_core, 'hybrid_search',
+            return_value=[
+                {"entity": {"text": "content 1", "score": 0.9}},
+                {"entity": {"text": "content 2", "score": 0.8}},
+            ]
+        )
+
+        # Mock build_file_download_url
+        mocker.patch.object(
+            tool.datamate_core.client, 'build_file_download_url',
+            return_value="http://dl/kb1/file"
+        )
+
+        result_json = tool.forward("test query")
+        results = json.loads(result_json)
+
+        # Verify rerank was called - smolagents Tool passes explicit values correctly
+        mock_rerank_model.rerank.assert_called_once()
+        call_args = mock_rerank_model.rerank.call_args
+        assert call_args[1]["query"] == "test query"
+        assert len(call_args[1]["documents"]) == 2
+
+    def test_forward_rerank_disabled(self, mock_observer: MessageObserver, mocker: MockFixture):
+        """Test forward method when rerank is disabled."""
+        tool = DataMateSearchTool(
+            server_url="http://127.0.0.1:8080",
+            index_names=["kb1"],
+            top_k=3,
+            observer=mock_observer,
+        )
+
+        # Mock hybrid_search method on the tool instance
+        mocker.patch.object(
+            tool.datamate_core, 'hybrid_search',
+            return_value=[
+                {"entity": {"text": "content 1", "score": 0.9}},
+            ]
+        )
+
+        # Mock build_file_download_url
+        mocker.patch.object(
+            tool.datamate_core.client, 'build_file_download_url',
+            return_value="http://dl/kb1/file"
+        )
+
+        result_json = tool.forward("test query")
+        results = json.loads(result_json)
+
+        # Verify results are returned without reranking
+        assert len(results) > 0
+
+    def test_forward_rerank_error_continues(self, mock_observer: MessageObserver, mocker: MockFixture):
+        """Test that forward continues when rerank raises an exception."""
+        # Create mock rerank model that raises exception
+        mock_rerank_model = MagicMock()
+        mock_rerank_model.rerank.side_effect = Exception("Rerank API error")
+
+        tool = DataMateSearchTool(
+            server_url="http://127.0.0.1:8080",
+            index_names=["kb1"],
+            top_k=3,
+            rerank=True,
+            rerank_model=mock_rerank_model,
+            observer=mock_observer,
+        )
+
+        # Mock hybrid_search method on the tool instance
+        mocker.patch.object(
+            tool.datamate_core, 'hybrid_search',
+            return_value=[
+                {"entity": {"text": "content 1", "score": 0.9}},
+            ]
+        )
+
+        # Mock build_file_download_url
+        mocker.patch.object(
+            tool.datamate_core.client, 'build_file_download_url',
+            return_value="http://dl/kb1/file"
+        )
+
+        result_json = tool.forward("test query")
+        results = json.loads(result_json)
+
+        # Should still return results despite rerank error
+        assert len(results) > 0
+
+        # Should not raise, should continue with original results
+        result_json = tool.forward("test query")
+        assert result_json is not None
+
+
+class TestDataMateSearchToolEdgeCases:
+    """Tests for edge cases and partial coverage scenarios."""
+
+    def test_verify_ssl_default_for_https(self, mock_observer: MessageObserver):
+        """Test that verify_ssl defaults correctly for HTTPS URLs when not specified."""
+        # When verify_ssl is None and use_https is True, verify_ssl should be False
+        tool = DataMateSearchTool(
+            server_url="https://datamate.example.com:8443",
+            verify_ssl=None,  # Not specified - should default based on protocol
+            observer=mock_observer,
+        )
+
+        # For HTTPS, default should be False (for self-signed certificates)
+        assert tool.verify_ssl is False
+
+    def test_verify_ssl_explicit_true_for_https(self, mock_observer: MessageObserver):
+        """Test explicit verify_ssl=True for HTTPS URLs."""
+        tool = DataMateSearchTool(
+            server_url="https://datamate.example.com:8443",
+            verify_ssl=True,
+            observer=mock_observer,
+        )
+
+        assert tool.verify_ssl is True
+
+    def test_verify_ssl_explicit_false_for_http(self, mock_observer: MessageObserver):
+        """Test explicit verify_ssl=False for HTTP URLs."""
+        tool = DataMateSearchTool(
+            server_url="http://datamate.example.com:8080",
+            verify_ssl=False,
+            observer=mock_observer,
+        )
+
+        # When explicitly set to False, it should use that value
+        # Note: The comment about "always verify for HTTP" only applies when verify_ssl is None
+        assert tool.verify_ssl is False
+
+    def test_parse_metadata_with_dict_input(self, datamate_tool):
+        """Test _parse_metadata with dict input (passthrough)."""
+        metadata_dict = {"file_name": "test.txt", "author": "test"}
+        result = datamate_tool._parse_metadata(metadata_dict)
+
+        assert result == metadata_dict
+
+    def test_parse_metadata_with_empty_string(self, datamate_tool):
+        """Test _parse_metadata with empty string."""
+        result = datamate_tool._parse_metadata("")
+
+        assert result == {}
+
+    def test_extract_dataset_id_empty_path(self, datamate_tool):
+        """Test _extract_dataset_id with empty path."""
+        result = datamate_tool._extract_dataset_id("")
+
+        assert result == ""
+
+    def test_extract_dataset_id_root_path(self, datamate_tool):
+        """Test _extract_dataset_id with root path."""
+        result = datamate_tool._extract_dataset_id("/")
+
+        assert result == ""
+
+    def test_extract_dataset_id_single_segment(self, datamate_tool):
+        """Test _extract_dataset_id with single path segment."""
+        result = datamate_tool._extract_dataset_id("dataset123")
+
+        assert result == "dataset123"
diff --git a/test/sdk/core/tools/test_dify_search_tool.py b/test/sdk/core/tools/test_dify_search_tool.py
index af62629d2..d68eaff2f 100644
--- a/test/sdk/core/tools/test_dify_search_tool.py
+++ b/test/sdk/core/tools/test_dify_search_tool.py
@@ -28,6 +28,7 @@ def dify_tool(mock_observer: MessageObserver) -> DifySearchTool:
             dataset_ids='["dataset1", "dataset2"]',
             top_k=3,
             observer=mock_observer,
+            rerank=False,
         )
         # Store the mock client for tests to use
         tool._mock_http_client = mock_client
@@ -73,6 +74,7 @@ def test_init_success(self, mock_observer: MessageObserver):
             dataset_ids='["ds1", "ds2"]',
             top_k=5,
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.server_url == "https://api.dify.ai/v1"
@@ -90,6 +92,7 @@ def test_init_singledataset_id(self, mock_observer: MessageObserver):
             api_key="test_key",
             dataset_ids='["single_dataset"]',
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.server_url == "https://api.dify.ai/v1"
@@ -101,6 +104,7 @@ def test_init_json_string_array_dataset_ids(self, mock_observer: MessageObserver
             api_key="test_key",
             dataset_ids='["0ab7096c-dfa5-4e0e-9dad-9265781447a3"]',
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.server_url == "https://api.dify.ai/v1"
@@ -112,6 +116,7 @@ def test_init_json_string_array_multiple_dataset_ids(self, mock_observer: Messag
             api_key="test_key",
             dataset_ids='["ds1", "ds2", "ds3"]',
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.server_url == "https://api.dify.ai/v1"
@@ -176,6 +181,7 @@ def test_init_dataset_ids_as_list(self, mock_observer: MessageObserver):
             api_key="test_key",
             dataset_ids=["ds1", "ds2", "ds3"],
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.dataset_ids == ["ds1", "ds2", "ds3"]
@@ -188,6 +194,7 @@ def test_init_dataset_ids_as_list_single_item(self, mock_observer: MessageObserv
             api_key="test_key",
             dataset_ids=["single_dataset"],
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.dataset_ids == ["single_dataset"]
@@ -200,6 +207,7 @@ def test_init_dataset_ids_as_list_with_numeric_ids(self, mock_observer: MessageO
             api_key="test_key",
             dataset_ids=[123, 456, 789],
             observer=mock_observer,
+            rerank=False,
         )
 
         assert tool.dataset_ids == ["123", "456", "789"]
@@ -219,6 +227,7 @@ def test_init_invalid_json_format(self, invalid_json, expected_error_contains, m
                 api_key="test_key",
                 dataset_ids=invalid_json,
                 observer=mock_observer,
+                rerank=False,
             )
         assert expected_error_contains in str(excinfo.value)
 
@@ -230,6 +239,7 @@ def test_init_dataset_ids_with_malformed_json_array(self, mock_observer: Message
                 api_key="test_key",
                 dataset_ids='["ds1", "ds2"',  # Missing closing bracket
                 observer=mock_observer,
+                rerank=False,
             )
         assert "dataset_ids must be a valid JSON string array or list" in str(excinfo.value)
 
@@ -240,6 +250,7 @@ def test_init_dataset_ids_json_string_with_non_string_elements(self, mock_observ
             api_key="test_key",
             dataset_ids='["ds1", 123, true, null]',
             observer=mock_observer,
+            rerank=False,
         )
 
         # Elements should be converted to strings using Python's str()
@@ -497,6 +508,7 @@ def test_forward_no_observer(self):
                 api_key="test_api_key",
                 dataset_ids='["dataset1"]',
                 observer=None,
+                rerank=False,
             )
             tool._mock_http_client = mock_client
             self._setup_success_flow(tool)
@@ -564,3 +576,360 @@ def test_forward_download_url_error_still_works(self, dify_tool: DifySearchTool)
         assert len(results) == 2  # Still processes results even with download URL failure
         assert results[0]["title"] == "document1.txt"
         # URL should be empty string due to download failure
+
+
+class TestDifySearchToolRerank:
+    """Tests for DifySearchTool rerank functionality."""
+
+    def test_init_with_rerank_params(self, mock_observer: MessageObserver):
+        """Test initialization with rerank parameters."""
+        tool = DifySearchTool(
+            server_url="https://api.dify.ai/v1",
+            api_key="test_key",
+            dataset_ids='["ds1", "ds2"]',
+            top_k=5,
+            rerank=True,
+            rerank_model_name="gte-rerank-v2",
+            rerank_model=None,
+            observer=mock_observer,
+        )
+
+        assert tool.rerank is True
+        assert tool.rerank_model_name == "gte-rerank-v2"
+        assert tool.rerank_model is None
+
+    def test_init_without_rerank_params(self, mock_observer: MessageObserver):
+        """Test initialization without rerank parameters (defaults)."""
+        tool = DifySearchTool(
+            server_url="https://api.dify.ai/v1",
+            api_key="test_key",
+            dataset_ids='["ds1"]',
+            observer=mock_observer,
+        )
+
+        # smolagents Tool doesn't properly handle Field defaults, so we check FieldInfo.default
+        try:
+            from pydantic import FieldInfo
+        except ImportError:
+            from pydantic.fields import FieldInfo
+        assert isinstance(tool.rerank, FieldInfo)
+        assert tool.rerank.default is False
+        assert tool.rerank_model_name.default == ""
+        assert tool.rerank_model.default is None
+
+    def test_forward_with_rerank_enabled(self, mock_observer: MessageObserver):
+        """Test forward method when rerank is enabled and model is provided."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            # Create mock rerank model
+            mock_rerank_model = MagicMock()
+            mock_rerank_model.rerank.return_value = [
+                {"index": 1, "relevance_score": 0.95, "document": "content 2"},
+                {"index": 0, "relevance_score": 0.85, "document": "content 1"},
+            ]
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                top_k=3,
+                rerank=True,
+                rerank_model_name="gte-rerank-v2",
+                rerank_model=mock_rerank_model,
+                observer=mock_observer,
+            )
+
+            # Setup mock search response
+            search_response = {
+                "query": "test query",
+                "records": [
+                    {
+                        "segment": {"content": "content 1", "document": {"id": "doc1", "name": "doc1.txt"}},
+                        "score": 0.9
+                    },
+                    {
+                        "segment": {"content": "content 2", "document": {"id": "doc2", "name": "doc2.txt"}},
+                        "score": 0.8
+                    }
+                ]
+            }
+
+            mock_search_response = MagicMock()
+            mock_search_response.status_code = 200
+            mock_search_response.json.return_value = search_response
+
+            mock_download_response = MagicMock()
+            mock_download_response.status_code = 200
+            mock_download_response.json.return_value = {"download_url": "https://example.com/file.pdf"}
+
+            mock_client.post.return_value = mock_search_response
+            mock_client.get.return_value = mock_download_response
+
+            result_json = tool.forward("test query")
+            results = json.loads(result_json)
+
+            # Verify rerank was called
+            mock_rerank_model.rerank.assert_called_once()
+            call_args = mock_rerank_model.rerank.call_args
+            assert call_args[1]["query"] == "test query"
+            assert len(call_args[1]["documents"]) == 2
+
+    def test_forward_rerank_disabled(self, mock_observer: MessageObserver):
+        """Test forward method when rerank is disabled."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                top_k=3,
+                rerank=False,
+                rerank_model=None,
+                observer=mock_observer,
+            )
+
+            # Setup mock search response
+            search_response = {
+                "query": "test query",
+                "records": [
+                    {
+                        "segment": {"content": "content 1", "document": {"id": "doc1", "name": "doc1.txt"}},
+                        "score": 0.9
+                    }
+                ]
+            }
+
+            mock_search_response = MagicMock()
+            mock_search_response.status_code = 200
+            mock_search_response.json.return_value = search_response
+
+            mock_download_response = MagicMock()
+            mock_download_response.status_code = 200
+            mock_download_response.json.return_value = {"download_url": "https://example.com/file.pdf"}
+
+            mock_client.post.return_value = mock_search_response
+            mock_client.get.return_value = mock_download_response
+
+            result_json = tool.forward("test query")
+
+            # Should work normally without reranking
+            assert result_json is not None
+
+    def test_forward_rerank_error_continues(self, mock_observer: MessageObserver):
+        """Test that forward continues when rerank raises an exception."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            # Create mock rerank model that raises exception
+            mock_rerank_model = MagicMock()
+            mock_rerank_model.rerank.side_effect = Exception("Rerank API error")
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                top_k=3,
+                rerank=True,
+                rerank_model=mock_rerank_model,
+                observer=mock_observer,
+            )
+
+            # Setup mock search response
+            search_response = {
+                "query": "test query",
+                "records": [
+                    {
+                        "segment": {"content": "content 1", "document": {"id": "doc1", "name": "doc1.txt"}},
+                        "score": 0.9
+                    }
+                ]
+            }
+
+            mock_search_response = MagicMock()
+            mock_search_response.status_code = 200
+            mock_search_response.json.return_value = search_response
+
+            mock_download_response = MagicMock()
+            mock_download_response.status_code = 200
+            mock_download_response.json.return_value = {"download_url": "https://example.com/file.pdf"}
+
+            mock_client.post.return_value = mock_search_response
+            mock_client.get.return_value = mock_download_response
+
+            # Should not raise, should continue with original results
+            result_json = tool.forward("test query")
+            assert result_json is not None
+
+
+class TestDifySearchToolEdgeCases:
+    """Edge case tests for DifySearchTool."""
+
+    def test_get_document_download_url_empty_id(self, mock_observer: MessageObserver):
+        """Test _get_document_download_url returns empty string for empty document_id."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._get_document_download_url("")
+            assert result == ""
+
+    def test_get_document_download_url_request_error(self, mock_observer: MessageObserver):
+        """Test _get_document_download_url handles RequestError."""
+        import httpx
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+            mock_client.get.side_effect = httpx.RequestError("request failed")
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._get_document_download_url("doc123", "dataset1")
+            assert result == ""
+
+    def test_get_document_download_url_http_status_error(self, mock_observer: MessageObserver):
+        """Test _get_document_download_url handles HTTPStatusError."""
+        import httpx
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            mock_response = MagicMock()
+            mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+                "404 Not Found", request=MagicMock(), response=MagicMock()
+            )
+            mock_client.get.return_value = mock_response
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._get_document_download_url("doc123", "dataset1")
+            assert result == ""
+
+    def test_get_document_download_url_json_decode_error(self, mock_observer: MessageObserver):
+        """Test _get_document_download_url handles JSONDecodeError."""
+        import json
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            mock_response = MagicMock()
+            mock_response.raise_for_status = MagicMock()
+            mock_response.json.side_effect = json.JSONDecodeError("invalid json", "", 0)
+            mock_client.get.return_value = mock_response
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._get_document_download_url("doc123", "dataset1")
+            assert result == ""
+
+    def test_get_document_download_url_missing_key(self, mock_observer: MessageObserver):
+        """Test _get_document_download_url handles missing download_url key."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            mock_response = MagicMock()
+            mock_response.raise_for_status = MagicMock()
+            mock_response.json.return_value = {}  # No download_url key
+            mock_client.get.return_value = mock_response
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._get_document_download_url("doc123", "dataset1")
+            assert result == ""
+
+    def test_batch_get_download_urls_empty_pairs(self, mock_observer: MessageObserver):
+        """Test _batch_get_download_urls with empty pairs."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            result = tool._batch_get_download_urls([])
+            assert result == {}
+
+    def test_batch_get_download_urls_with_empty_document_id(self, mock_observer: MessageObserver):
+        """Test _batch_get_download_urls handles empty document_id."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager, \
+             patch.object(DifySearchTool, "_get_document_download_url", return_value=""):
+
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            # Include an empty document_id in the pairs
+            result = tool._batch_get_download_urls([("", "dataset1"), ("doc123", "dataset1")])
+            assert result == {"": "", "doc123": ""}
+
+    def test_search_dify_knowledge_base_missing_records_key(self, mock_observer: MessageObserver):
+        """Test _search_dify_knowledge_base raises when records key is missing."""
+        with patch("sdk.nexent.core.tools.dify_search_tool.http_client_manager") as mock_manager:
+            mock_client = MagicMock()
+            mock_manager.get_sync_client.return_value = mock_client
+
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {"query": "test"}  # Missing "records" key
+            mock_response.raise_for_status = MagicMock()
+            mock_client.post.return_value = mock_response
+
+            tool = DifySearchTool(
+                server_url="https://api.dify.ai/v1",
+                api_key="test_api_key",
+                dataset_ids='["dataset1"]',
+                observer=mock_observer,
+                rerank=False,
+            )
+
+            with pytest.raises(Exception, match="Unexpected Dify API response format"):
+                tool._search_dify_knowledge_base("test", 3, "semantic_search", "dataset1")
diff --git a/test/sdk/core/tools/test_knowledge_base_search_tool.py b/test/sdk/core/tools/test_knowledge_base_search_tool.py
index 9ac1d6c51..ad6c7987b 100644
--- a/test/sdk/core/tools/test_knowledge_base_search_tool.py
+++ b/test/sdk/core/tools/test_knowledge_base_search_tool.py
@@ -38,7 +38,8 @@ def knowledge_base_search_tool(mock_observer, mock_vdb_core, mock_embedding_mode
         observer=mock_observer,
         embedding_model=mock_embedding_model,
         vdb_core=mock_vdb_core,
-        search_mode="hybrid"
+        search_mode="hybrid",
+        rerank=False,
     )
     return tool
 
@@ -88,7 +89,8 @@ def test_init_with_custom_values(self, mock_observer, mock_vdb_core, mock_embedd
             observer=mock_observer,
             embedding_model=mock_embedding_model,
             vdb_core=mock_vdb_core,
-            search_mode="semantic"
+            search_mode="semantic",
+            rerank=False,
         )
 
         assert tool.top_k == 10
@@ -106,7 +108,8 @@ def test_init_with_none_index_names(self, mock_vdb_core, mock_embedding_model):
             observer=None,
             embedding_model=mock_embedding_model,
             vdb_core=mock_vdb_core,
-            search_mode="hybrid"
+            search_mode="hybrid",
+            rerank=False,
         )
 
         assert tool.index_names == []
@@ -117,7 +120,7 @@ def test_search_hybrid_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(3)
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_hybrid("test query", ["test_index1"])
+        result = knowledge_base_search_tool.search_hybrid("test query", ["test_index1"], top_k=5)
 
         # Verify result structure
         assert result["total"] == 3
@@ -145,7 +148,7 @@ def test_search_accurate_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(2)
         knowledge_base_search_tool.vdb_core.accurate_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_accurate("test query", ["test_index1"])
+        result = knowledge_base_search_tool.search_accurate("test query", ["test_index1"], top_k=5)
 
         # Verify result structure
         assert result["total"] == 2
@@ -164,7 +167,7 @@ def test_search_semantic_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(4)
         knowledge_base_search_tool.vdb_core.semantic_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_semantic("test query", ["test_index1"])
+        result = knowledge_base_search_tool.search_semantic("test query", ["test_index1"], top_k=5)
 
         # Verify result structure
         assert result["total"] == 4
@@ -183,7 +186,7 @@ def test_search_hybrid_error(self, knowledge_base_search_tool):
         knowledge_base_search_tool.vdb_core.hybrid_search.side_effect = Exception("Search error")
 
         with pytest.raises(Exception) as excinfo:
-            knowledge_base_search_tool.search_hybrid("test query", ["test_index1"])
+            knowledge_base_search_tool.search_hybrid("test query", ["test_index1"], top_k=5)
 
         assert "Error during semantic search" in str(excinfo.value)
 
@@ -303,13 +306,190 @@ def test_forward_title_fallback(self, knowledge_base_search_tool):
         assert len(search_results) == 1
         assert search_results[0]["title"] == "test.txt"
 
-    def test_forward_requires_index_names(self, knowledge_base_search_tool):
-        """Test forward method requires index_names parameter"""
-        # Test that TypeError is raised when index_names is not provided
-        with pytest.raises(TypeError) as excinfo:
-            knowledge_base_search_tool.forward("test query")
 
-        assert "index_names" in str(excinfo.value)
+class TestKnowledgeBaseSearchToolRerank:
+    """Tests for KnowledgeBaseSearchTool rerank functionality."""
+
+    def test_init_with_rerank_params(self, mock_observer):
+        """Test initialization with rerank parameters."""
+        tool = KnowledgeBaseSearchTool(
+            index_names=["kb1", "kb2"],
+            search_mode="hybrid",
+            rerank=True,
+            rerank_model_name="gte-rerank-v2",
+            rerank_model=None,
+            vdb_core=None,
+            embedding_model=None,
+            observer=mock_observer,
+        )
+
+        assert tool.rerank is True
+        assert tool.rerank_model_name == "gte-rerank-v2"
+        assert tool.rerank_model is None
+
+    def test_init_without_rerank_params(self, mock_observer):
+        """Test initialization without rerank parameters (defaults)."""
+        tool = KnowledgeBaseSearchTool(
+            index_names=["kb1"],
+            search_mode="semantic",
+            vdb_core=None,
+            embedding_model=None,
+            observer=mock_observer,
+        )
+
+        # smolagents Tool doesn't properly handle Field defaults, so we check FieldInfo.default
+        try:
+            from pydantic import FieldInfo
+        except ImportError:
+            from pydantic.fields import FieldInfo
+        assert isinstance(tool.rerank, FieldInfo)
+        assert tool.rerank.default is False
+        assert tool.rerank_model_name.default == ""
+        assert tool.rerank_model.default is None
+
+    def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_embedding_model, mocker):
+        """Test forward method when rerank is enabled and model is provided."""
+        # Mock search results
+        mock_results = [
+            {
+                "document": {
+                    "title": "doc1",
+                    "content": "content 1 about machine learning",
+                    "filename": "doc1.txt",
+                    "path_or_url": "/path/doc1.txt",
+                    "create_time": "2024-01-01T12:00:00Z",
+                    "source_type": "file"
+                },
+                "score": 0.9,
+                "index": "kb1"
+            },
+            {
+                "document": {
+                    "title": "doc2",
+                    "content": "content 2 about deep learning",
+                    "filename": "doc2.txt",
+                    "path_or_url": "/path/doc2.txt",
+                    "create_time": "2024-01-01T12:00:00Z",
+                    "source_type": "file"
+                },
+                "score": 0.8,
+                "index": "kb1"
+            }
+        ]
+        mock_vdb_core.hybrid_search.return_value = mock_results
+
+        # Create mock rerank model
+        mock_rerank_model = MagicMock()
+        mock_rerank_model.rerank.return_value = [
+            {"index": 1, "relevance_score": 0.95, "document": "content 2 about deep learning"},
+            {"index": 0, "relevance_score": 0.85, "document": "content 1 about machine learning"},
+        ]
+
+        tool = KnowledgeBaseSearchTool(
+            index_names=["kb1"],
+            search_mode="hybrid",
+            top_k=3,
+            rerank=True,
+            rerank_model_name="gte-rerank-v2",
+            rerank_model=mock_rerank_model,
+            vdb_core=mock_vdb_core,
+            embedding_model=mock_embedding_model,
+            observer=mock_observer,
+        )
+
+        result = tool.forward("test query")
+        results = json.loads(result)
+
+        # Verify rerank was called
+        mock_rerank_model.rerank.assert_called_once()
+        call_args = mock_rerank_model.rerank.call_args
+        assert call_args[1]["query"] == "test query"
+        assert len(call_args[1]["documents"]) == 2
+
+    def test_forward_rerank_disabled(self, mock_observer, mock_vdb_core, mock_embedding_model):
+        """Test forward method when rerank is disabled."""
+        # Mock search results
+        mock_results = [
+            {
+                "document": {
+                    "title": "doc1",
+                    "content": "content 1",
+                    "filename": "doc1.txt",
+                    "path_or_url": "/path/doc1.txt",
+                    "create_time": "2024-01-01T12:00:00Z",
+                    "source_type": "file"
+                },
+                "score": 0.9,
+                "index": "kb1"
+            }
+        ]
+        mock_vdb_core.hybrid_search.return_value = mock_results
+
+        tool = KnowledgeBaseSearchTool(
+            index_names=["kb1"],
+            search_mode="hybrid",
+            rerank=False,
+            rerank_model=None,
+            vdb_core=mock_vdb_core,
+            embedding_model=mock_embedding_model,
+            observer=mock_observer,
+        )
+
+        result = tool.forward("test query")
+
+        # Should work normally without reranking
+        assert result is not None
+
+    def test_forward_rerank_error_continues(self, mock_observer, mock_vdb_core, mock_embedding_model):
+        """Test that forward continues when rerank raises an exception."""
+        # Mock search results
+        mock_results = [
+            {
+                "document": {
+                    "title": "doc1",
+                    "content": "content 1",
+                    "filename": "doc1.txt",
+                    "path_or_url": "/path/doc1.txt",
+                    "create_time": "2024-01-01T12:00:00Z",
+                    "source_type": "file"
+                },
+                "score": 0.9,
+                "index": "kb1"
+            }
+        ]
+        mock_vdb_core.hybrid_search.return_value = mock_results
+
+        # Create mock rerank model that raises exception
+        mock_rerank_model = MagicMock()
+        mock_rerank_model.rerank.side_effect = Exception("Rerank API error")
+
+        tool = KnowledgeBaseSearchTool(
+            index_names=["kb1"],
+            search_mode="hybrid",
+            top_k=3,
+            rerank=True,
+            rerank_model=mock_rerank_model,
+            vdb_core=mock_vdb_core,
+            embedding_model=mock_embedding_model,
+            observer=mock_observer,
+        )
+
+        # Should not raise, should continue with original results
+        result = tool.forward("test query")
+        assert result is not None
+
+    def test_forward_uses_instance_index_names(self, knowledge_base_search_tool):
+        """Test forward method uses instance index_names when not provided"""
+        # Mock search results
+        mock_results = create_mock_search_result(2)
+        knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
+
+        # Call forward without index_names - should use instance's index_names
+        result = knowledge_base_search_tool.forward("test query")
+
+        # Verify it used instance index_names
+        assert result is not None
+        knowledge_base_search_tool.vdb_core.hybrid_search.assert_called_once()
 
     def test_forward_empty_index_names_string(self, knowledge_base_search_tool):
         """Test forward method with empty index_names string returns no results"""
diff --git a/test/sdk/core/tools/test_read_skill_md_tool.py b/test/sdk/core/tools/test_read_skill_md_tool.py
index 9a49b861c..bdffa0e69 100644
--- a/test/sdk/core/tools/test_read_skill_md_tool.py
+++ b/test/sdk/core/tools/test_read_skill_md_tool.py
@@ -497,3 +497,124 @@ def test_get_tool_reuses_with_different_params(self):
         # Should have the original params from first call
         assert tool1.local_skills_dir == "/path/one"
         assert tool1.agent_id == 1
+
+
+class TestReadDirectFile:
+    """Test _read_direct_file method for empty skill_name."""
+
+    def test_read_direct_file_no_local_dir(self, read_skill_md_tool):
+        """Test _read_direct_file without local_skills_dir returns error."""
+        read_skill_md_tool.local_skills_dir = None
+        result = read_skill_md_tool._read_direct_file(())
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
+
+    def test_read_direct_file_default_skill_md(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads SKILL.md when no path specified."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create SKILL.md in root
+        skill_md = """---
+name: root-skill
+description: Root skill
+---
+# Root Content
+"""
+        with open(os.path.join(temp_skills_dir, "SKILL.md"), 'w', encoding='utf-8') as f:
+            f.write(skill_md)
+
+        result = read_skill_md_tool._read_direct_file(())
+
+        assert "Root Content" in result
+        assert "name:" not in result  # frontmatter stripped
+
+    def test_read_direct_file_with_path(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads specified file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create a file in root
+        test_file = os.path.join(temp_skills_dir, "test-file.txt")
+        with open(test_file, 'w', encoding='utf-8') as f:
+            f.write("test content")
+
+        result = read_skill_md_tool._read_direct_file(("test-file.txt",))
+
+        assert "test content" in result
+
+    def test_read_direct_file_nested_path(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file reads nested file path."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create nested file
+        nested_dir = os.path.join(temp_skills_dir, "subdir")
+        os.makedirs(nested_dir)
+        nested_file = os.path.join(nested_dir, "nested.md")
+        with open(nested_file, 'w', encoding='utf-8') as f:
+            f.write("""---
+title: Nested
+---
+# Nested Content
+""")
+
+        result = read_skill_md_tool._read_direct_file(("subdir", "nested.md"))
+
+        assert "Nested Content" in result
+        assert "title:" not in result  # frontmatter stripped
+
+    def test_read_direct_file_not_found(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file returns error for missing file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        result = read_skill_md_tool._read_direct_file(("missing.txt",))
+        assert "not found" in result.lower()
+
+    def test_read_direct_file_exception(self, read_skill_md_tool, temp_skills_dir):
+        """Test _read_direct_file handles read exceptions."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create file but mock open to raise error
+        test_file = os.path.join(temp_skills_dir, "error.md")
+        with open(test_file, 'w') as f:
+            f.write("content")
+
+        with patch('builtins.open', side_effect=OSError("Read error")):
+            result = read_skill_md_tool._read_direct_file(("error.md",))
+        assert "[Error]" in result
+
+
+class TestExecuteEmptySkillName:
+    """Test execute with empty skill_name (reads directly from local_skills_dir)."""
+
+    def test_execute_empty_skill_name_reads_root(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name reads from local_skills_dir root."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create SKILL.md in root
+        skill_md = """---
+name: root
+description: Root skill
+---
+# Root Skill Content
+"""
+        with open(os.path.join(temp_skills_dir, "SKILL.md"), 'w', encoding='utf-8') as f:
+            f.write(skill_md)
+
+        result = read_skill_md_tool.execute("")
+
+        assert "Root Skill Content" in result
+
+    def test_execute_empty_skill_name_with_file(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name and additional_files parameter."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        # Create a file
+        test_file = os.path.join(temp_skills_dir, "readme.md")
+        with open(test_file, 'w', encoding='utf-8') as f:
+            f.write("""---
+title: Readme
+---
+# Readme Content
+""")
+
+        result = read_skill_md_tool.execute("", "readme.md")
+
+        assert "Readme Content" in result
+
+    def test_execute_empty_skill_name_file_not_found(self, read_skill_md_tool, temp_skills_dir):
+        """Test execute with empty skill_name returns error for missing file."""
+        read_skill_md_tool.local_skills_dir = temp_skills_dir
+        result = read_skill_md_tool.execute("", "nonexistent.txt")
+        assert "not found" in result.lower()
diff --git a/test/sdk/core/tools/test_write_skill_file_tool.py b/test/sdk/core/tools/test_write_skill_file_tool.py
index e8591a119..964c66ce9 100644
--- a/test/sdk/core/tools/test_write_skill_file_tool.py
+++ b/test/sdk/core/tools/test_write_skill_file_tool.py
@@ -188,12 +188,6 @@ def test_lazy_load_reuses_manager(self, write_skill_file_tool):
 class TestExecute:
     """Test execute method."""
 
-    def test_execute_empty_skill_name(self, write_skill_file_tool):
-        """Test execute with empty skill_name."""
-        result = write_skill_file_tool.execute("", "file.txt", "content")
-        assert "[Error]" in result
-        assert "skill_name" in result.lower()
-
     def test_execute_empty_file_path(self, write_skill_file_tool):
         """Test execute with empty file_path."""
         result = write_skill_file_tool.execute("skill", "", "content")
@@ -301,14 +295,17 @@ def test_execute_writes_skill_md(self, write_skill_file_tool, temp_skills_dir):
 
     def test_execute_handles_manager_init_error(self, write_skill_file_tool, temp_skills_dir):
         """Test execute handles errors during skill manager initialization."""
-        # Force an error during _get_skill_manager
-        write_skill_file_tool.skill_manager = None
+        # When skill_name is empty and local_skills_dir is None, it returns direct error
+        # So we test with a non-empty skill_name to trigger manager init error
         write_skill_file_tool.local_skills_dir = None
+        write_skill_file_tool.skill_manager = None
 
-        result = write_skill_file_tool.execute("skill", "file.txt", "content")
+        # Mock _get_skill_manager to raise exception
+        with patch.object(write_skill_file_tool, '_get_skill_manager', side_effect=ImportError("Import failed")):
+            result = write_skill_file_tool.execute("skill", "file.txt", "content")
 
         assert "[Error]" in result
-        assert "Failed to initialize" in result or "skill manager" in result.lower()
+        assert "Failed to initialize" in result
 
     def test_execute_handles_write_error(self, write_skill_file_tool, temp_skills_dir):
         """Test execute handles errors during file write."""
@@ -681,3 +678,88 @@ def test_execute_with_leading_slash(self, write_skill_file_tool, temp_skills_dir
         # File should be created without leading slash
         expected_path = os.path.join(temp_skills_dir, skill_name, "file.txt")
         assert os.path.exists(expected_path)
+
+
+class TestWriteDirectFile:
+    """Test _write_direct_file method for empty skill_name."""
+
+    def test_write_direct_file_no_local_dir(self, write_skill_file_tool):
+        """Test _write_direct_file without local_skills_dir returns error."""
+        write_skill_file_tool.local_skills_dir = None
+        result = write_skill_file_tool._write_direct_file("file.txt", "content")
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
+
+    def test_write_direct_file_creates_file(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file creates file directly in local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool._write_direct_file("direct-file.txt", "direct content")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "direct-file.txt")
+        assert os.path.exists(file_path)
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "direct content"
+
+    def test_write_direct_file_nested_path(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file creates nested directories."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool._write_direct_file("subdir/nested/file.py", "print('hello')")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "subdir", "nested", "file.py")
+        assert os.path.exists(file_path)
+
+    def test_write_direct_file_overwrites(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file overwrites existing file."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        file_path = os.path.join(temp_skills_dir, "overwrite.txt")
+
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write("old content")
+
+        result = write_skill_file_tool._write_direct_file("overwrite.txt", "new content")
+
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "new content"
+
+    def test_write_direct_file_error(self, write_skill_file_tool, temp_skills_dir):
+        """Test _write_direct_file handles write errors."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+
+        with patch('builtins.open', side_effect=PermissionError("Permission denied")):
+            result = write_skill_file_tool._write_direct_file("error.txt", "content")
+
+        assert "[Error]" in result or "Permission denied" in result
+
+
+class TestExecuteEmptySkillName:
+    """Test execute with empty skill_name (writes directly to local_skills_dir)."""
+
+    def test_execute_empty_skill_name_direct_write(self, write_skill_file_tool, temp_skills_dir):
+        """Test execute with empty skill_name writes directly to local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool.execute("", "root-file.txt", "root content")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "root-file.txt")
+        assert os.path.exists(file_path)
+        with open(file_path, 'r', encoding='utf-8') as f:
+            assert f.read() == "root content"
+
+    def test_execute_empty_skill_name_nested_path(self, write_skill_file_tool, temp_skills_dir):
+        """Test execute with empty skill_name and nested path."""
+        write_skill_file_tool.local_skills_dir = temp_skills_dir
+        result = write_skill_file_tool.execute("", "dir1/dir2/file.md", "# Markdown")
+
+        assert "Successfully" in result
+        file_path = os.path.join(temp_skills_dir, "dir1", "dir2", "file.md")
+        assert os.path.exists(file_path)
+
+    def test_execute_empty_skill_name_no_local_dir(self, write_skill_file_tool):
+        """Test execute with empty skill_name but no local_skills_dir."""
+        write_skill_file_tool.local_skills_dir = None
+        result = write_skill_file_tool.execute("", "file.txt", "content")
+
+        assert "[Error]" in result
+        assert "local_skills_dir" in result.lower()
diff --git a/test/sdk/core/utils/test_prompt_template_utils.py b/test/sdk/core/utils/test_prompt_template_utils.py
index 8c1788c39..c0a3ad634 100644
--- a/test/sdk/core/utils/test_prompt_template_utils.py
+++ b/test/sdk/core/utils/test_prompt_template_utils.py
@@ -86,22 +86,6 @@ def test_get_prompt_template_unsupported_type(self):
         assert "Unsupported template type" in str(excinfo.value)
         assert "unsupported_type" in str(excinfo.value)
 
-    @patch('builtins.open', new_callable=mock_open, read_data='system_prompt: "Test prompt"')
-    @patch('yaml.safe_load')
-    def test_get_prompt_template_with_kwargs(self, mock_yaml_load, mock_file):
-        """Test get_prompt_template with additional kwargs (should be logged but not used)"""
-        mock_yaml_load.return_value = {"system_prompt": "Test prompt"}
-
-        with patch('sdk.nexent.core.utils.prompt_template_utils.logger') as mock_logger:
-            result = get_prompt_template(template_type='analyze_image', language='en', extra_param='value')
-
-            # Verify kwargs were logged
-            log_calls = [str(call) for call in mock_logger.info.call_args_list]
-            assert any("extra_param" in str(call) or "kwargs" in str(call) for call in log_calls)
-
-            # Verify function still works
-            assert result == {"system_prompt": "Test prompt"}
-
     @patch('builtins.open', side_effect=FileNotFoundError("File not found"))
     def test_get_prompt_template_file_not_found(self, mock_file):
         """Test get_prompt_template when template file is not found"""
@@ -119,21 +103,6 @@ def test_get_prompt_template_yaml_error(self, mock_yaml_load, mock_file):
 
         assert "YAML parse error" in str(excinfo.value)
 
-    @patch('builtins.open', new_callable=mock_open, read_data='system_prompt: "Test prompt"')
-    @patch('yaml.safe_load')
-    @patch('sdk.nexent.core.utils.prompt_template_utils.logger')
-    def test_get_prompt_template_logging(self, mock_logger, mock_yaml_load, mock_file):
-        """Test that get_prompt_template logs correctly"""
-        mock_yaml_load.return_value = {"system_prompt": "Test prompt"}
-
-        get_prompt_template(template_type='analyze_image', language='en')
-
-        # Verify logger was called
-        mock_logger.info.assert_called_once()
-        log_call = str(mock_logger.info.call_args)
-        assert "analyze_image" in log_call
-        assert "en" in log_call
-
     @patch('builtins.open', new_callable=mock_open, read_data='system_prompt: "Test prompt"')
     @patch('yaml.safe_load')
     def test_get_prompt_template_path_construction(self, mock_yaml_load, mock_file):
diff --git a/test/sdk/skills/test_skill_loader.py b/test/sdk/skills/test_skill_loader.py
index 7212d838e..ee0718672 100644
--- a/test/sdk/skills/test_skill_loader.py
+++ b/test/sdk/skills/test_skill_loader.py
@@ -218,6 +218,18 @@ def test_escape_value_with_quotes(self):
         fixed = SkillLoader._fix_yaml_frontmatter(frontmatter)
         assert 'description: Say "hello" to YAML' in fixed
 
+    def test_skip_yaml_list_item_lines(self):
+        """Test that YAML list item lines (starting with '-') are preserved."""
+        frontmatter = """name: test
+allowed-tools:
+  - tool1
+  - tool2
+description: Test
+"""
+        fixed = SkillLoader._fix_yaml_frontmatter(frontmatter)
+        assert "- tool1" in fixed
+        assert "- tool2" in fixed
+
     def test_fix_value_with_multiple_special_chars(self):
         """Test fixing values with multiple special characters."""
         frontmatter = """name: test
@@ -341,8 +353,8 @@ def test_load_success(self, tmp_path):
 class TestSkillLoaderEdgeCases:
     """Test edge cases for SkillLoader."""
 
-    def test_parse_with_invalid_yaml_raises(self):
-        """Test parsing with invalid YAML structure."""
+    def test_parse_with_invalid_yaml_falls_back_to_regex(self):
+        """Test parsing with invalid YAML falls back to regex extraction."""
         content = """---
 name: test
 description: Test
@@ -350,8 +362,10 @@ def test_parse_with_invalid_yaml_raises(self):
 ---
 # Body
 """
-        with pytest.raises(Exception):
-            SkillLoader.parse(content)
+        # YAML parsing fails, but regex extraction succeeds since name/description are valid
+        result = SkillLoader.parse(content)
+        assert result["name"] == "test"
+        assert result["description"] == "Test"
 
     def test_parse_empty_content(self):
         """Test parsing empty content."""
@@ -380,7 +394,9 @@ def test_parse_with_yaml_list_frontmatter_raises(self):
 ---
 # Body
 """
-        with pytest.raises(ValueError, match="Invalid YAML frontmatter"):
+        # Frontmatter is a YAML list (not a dict), so regex fallback extracts nothing
+        # and raises because 'name' field is missing
+        with pytest.raises(ValueError, match="'name' field"):
             SkillLoader.parse(content)
 
     def test_parse_with_block_sequence_frontmatter_raises(self):
@@ -391,9 +407,71 @@ def test_parse_with_block_sequence_frontmatter_raises(self):
 ---
 # Body
 """
-        with pytest.raises(ValueError, match="Invalid YAML frontmatter"):
+        # Frontmatter is a YAML list (block sequence), so regex fallback extracts nothing
+        # and raises because 'name' field is missing
+        with pytest.raises(ValueError, match="'name' field"):
             SkillLoader.parse(content)
 
+    def test_regex_extract_block_scalar_description(self):
+        """Test regex extraction when description uses block scalar (>)."""
+        content = """---
+name: test
+description: >
+  This is a
+  multiline
+  description
+---
+# Body
+"""
+        # This triggers the regex fallback path because yaml.safe_load might fail
+        result = SkillLoader._extract_frontmatter_by_regex("name: test\ndescription: >\n  This is a\n  multiline\n  description")
+        assert "description" in result
+        assert "multiline" in result["description"]
+
+    def test_regex_extract_block_scalar_with_empty_lines(self):
+        """Test regex extraction with empty lines in block scalar content."""
+        frontmatter = """name: test
+description: >
+  Line 1
+
+  Line 2
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert "description" in result
+        assert "Line 1" in result["description"]
+        assert "Line 2" in result["description"]
+
+    def test_regex_extract_block_scalar_stops_at_unindented(self):
+        """Test regex extraction stops at unindented line."""
+        frontmatter = """name: test
+description: >
+  Line 1
+unindented_line
+  Line 2
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert "description" in result
+        assert "Line 1" in result["description"]
+        assert "unindented_line" not in result["description"]
+
+    def test_regex_extract_tags_inline(self):
+        """Test regex extraction of tags from inline list format."""
+        frontmatter = """name: test
+description: Test skill
+tags: [python, ml, data]
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert result["tags"] == ["python", "ml", "data"]
+
+    def test_regex_extract_allowed_tools_inline(self):
+        """Test regex extraction of allowed-tools from inline list format."""
+        frontmatter = """name: test
+description: Test skill
+allowed-tools: [tool1, tool2, tool3]
+"""
+        result = SkillLoader._extract_frontmatter_by_regex(frontmatter)
+        assert result["allowed-tools"] == ["tool1", "tool2", "tool3"]
+
     def test_parse_with_inline_yaml_list(self):
         """Test parsing with inline YAML list at top level."""
         content = """---
diff --git a/test/sdk/skills/test_skill_manager.py b/test/sdk/skills/test_skill_manager.py
index 625bc36b4..769ba7c0a 100644
--- a/test/sdk/skills/test_skill_manager.py
+++ b/test/sdk/skills/test_skill_manager.py
@@ -1180,5 +1180,770 @@ def test_upload_md_with_explicit_file_type(self):
             assert result["name"] == "explicit-type"
 
 
+    def test_upload_md_with_explicit_file_type(self):
+        """Test uploading MD with explicit file_type parameter."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            md_content = """---
+name: explicit-type
+description: Explicit type test
+---
+# Content
+"""
+
+            result = manager.upload_skill_from_file(
+                md_content, file_type="md"
+            )
+
+            assert result is not None
+            assert result["name"] == "explicit-type"
+
+    def test_upload_from_md_missing_name_raises(self):
+        """Test that MD without name raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            md_content = """---
+description: No name here
+---
+# Content
+"""
+            with pytest.raises(ValueError, match="Invalid SKILL.md format"):
+                manager.upload_skill_from_file(md_content)
+
+    def test_upload_zip_with_name_ending_in_zip(self):
+        """Test ZIP detection when skill_name ends with .zip."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("detected-skill/SKILL.md", """---
+name: detected-skill
+description: ZIP detected
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(
+                zip_bytes, skill_name="my-skill.zip"
+            )
+
+            assert result is not None
+            assert result["name"] == "my-skill.zip"
+
+    def test_upload_zip_unknown_skill_name_none_raises(self):
+        """Test that ZIP with None skill_name raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            # Create ZIP without any folder name hint
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("SKILL.md", """---
+name: SKILL
+description: No folder
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+
+            with pytest.raises(ValueError, match="Skill name is required"):
+                manager.upload_skill_from_file(zip_bytes, skill_name=None)
+
+    def test_upload_zip_with_backslash_paths(self):
+        """Test ZIP extraction with backslash paths (Windows)."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("backslash-skill\\SKILL.md", """---
+name: backslash-skill
+description: Backslash paths
+---
+# Content
+""")
+                zf.writestr("backslash-skill\\scripts\\test.py", "# Test script\n")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "backslash-skill"
+
+    def test_upload_zip_with_nested_structure(self):
+        """Test ZIP extraction with deeply nested structure."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("nested-skill/SKILL.md", """---
+name: nested-skill
+description: Nested
+---
+# Content
+""")
+                zf.writestr("nested-skill/data/configs/app.json", '{"key": "value"}')
+                zf.writestr("nested-skill/data/configs/dev.json", '{"env": "dev"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            skill_dir = os.path.join(temp.skills_dir, "nested-skill")
+            assert os.path.exists(os.path.join(skill_dir, "data", "configs", "app.json"))
+
+    def test_update_skill_md_auto_detect(self):
+        """Test updating skill with auto-detect file type."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "auto-update",
+                """---
+name: auto-update
+description: Original
+---
+# Original
+""",
+            )
+
+            new_md = """---
+name: auto-update
+description: Auto updated
+---
+# Updated
+"""
+            result = manager.update_skill_from_file(new_md, "auto-update")
+
+            assert result is not None
+            assert result["description"] == "Auto updated"
+
+    def test_update_skill_zip_with_backslash_paths(self):
+        """Test updating skill from ZIP with backslash paths."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "zip-update-bs",
+                """---
+name: zip-update-bs
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("zip-update-bs\\SKILL.md", """---
+name: zip-update-bs
+description: BS Updated
+---
+# BS Updated
+""")
+                zf.writestr("zip-update-bs\\scripts\\helper.py", "# Helper\n")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "zip-update-bs")
+
+            assert result is not None
+            assert result["description"] == "BS Updated"
+
+
+class TestSkillManagerAddToTree:
+    """Test SkillManager._add_to_tree method."""
+
+    def test_add_to_tree_single_file(self):
+        """Test adding single file to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["file.txt"], is_directory=False)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["name"] == "file.txt"
+        assert node["children"][0]["type"] == "file"
+
+    def test_add_to_tree_single_directory(self):
+        """Test adding single directory to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["subdir"], is_directory=True)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["name"] == "subdir"
+        assert node["children"][0]["type"] == "directory"
+
+    def test_add_to_tree_nested_path(self):
+        """Test adding nested path to tree."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, ["dir1", "dir2", "file.txt"], is_directory=False)
+
+        assert node["children"][0]["name"] == "dir1"
+        assert node["children"][0]["type"] == "directory"
+        assert node["children"][0]["children"][0]["name"] == "dir2"
+        assert node["children"][0]["children"][0]["type"] == "directory"
+        assert node["children"][0]["children"][0]["children"][0]["name"] == "file.txt"
+
+    def test_add_to_tree_skips_duplicate_same_type(self):
+        """Test that duplicate entries with same type are skipped."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "dup", "type": "file", "children": []}]}
+
+        manager._add_to_tree(node, ["dup"], is_directory=False)
+
+        assert len(node["children"]) == 1
+
+    def test_add_to_tree_empty_parts(self):
+        """Test that empty parts list does nothing."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": []}
+
+        manager._add_to_tree(node, [], is_directory=False)
+
+        assert len(node["children"]) == 0
+
+
+class TestSkillManagerDeleteSkill:
+    """Test SkillManager.delete_skill error handling."""
+
+    def test_delete_skill_with_os_error(self, mocker):
+        """Test deleting skill when os.error occurs."""
+        import shutil
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "delete-error",
+                """---
+name: delete-error
+description: Delete error test
+---
+# Content
+""",
+            )
+
+            skill_dir = os.path.join(temp.skills_dir, "delete-error")
+
+            # Mock at module level where skill_manager imports it
+            original_rmtree = shutil.rmtree
+            def mock_rmtree(path, **kwargs):
+                if path == skill_dir:
+                    raise OSError("Permission denied")
+                original_rmtree(path, **kwargs)
+
+            mocker.patch("shutil.rmtree", side_effect=mock_rmtree)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.delete_skill("delete-error")
+
+            # Should still return True (idempotent behavior)
+            assert result is True
+
+
+class TestSkillManagerBuildSkillsSummary:
+    """Test SkillManager.build_skills_summary edge cases."""
+
+    def test_build_summary_with_empty_description(self):
+        """Test building summary when skill has empty description."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            # Create a skill with empty description
+            skill_dir = os.path.join(temp.skills_dir, "empty-desc")
+            os.makedirs(skill_dir)
+            with open(os.path.join(skill_dir, "SKILL.md"), "w", encoding="utf-8") as f:
+                f.write("""---
+name: empty-desc
+description: 
+---
+# Content
+""")
+
+            result = manager.build_skills_summary()
+
+            assert "<skills>" in result
+            assert "<name>empty-desc</name>" in result
+
+
+class TestSkillManagerCleanupSkillDirectory:
+    """Test SkillManager.cleanup_skill_directory error handling."""
+
+    def test_cleanup_with_os_error(self, mocker):
+        """Test cleanup when os.remove fails."""
+        mocker.patch("os.listdir", return_value=[f"skill_test_fakeid"])
+        mocker.patch("os.path.isdir", return_value=False)
+        mocker.patch("os.remove", side_effect=OSError("Access denied"))
+        mocker.patch("os.path.join", side_effect=lambda *args: "\\".join(str(a) for a in args))
+
+        manager = SkillManager(local_skills_dir="/fake")
+        # Should not raise, just log warning
+        manager.cleanup_skill_directory("test")
+
+
+class TestSkillManagerRunSkillScript:
+    """Test SkillManager.run_skill_script error handling."""
+
+    def test_run_python_script_timeout(self, mocker):
+        """Test running Python script that times out."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "timeout-skill",
+                """---
+name: timeout-skill
+description: Timeout test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "slow.py", "content": "import time; time.sleep(1000)"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("cmd", 300))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(TimeoutError, match="timed out"):
+                manager.run_skill_script("timeout-skill", "scripts/slow.py")
+
+    def test_run_python_script_other_exception(self, mocker):
+        """Test running Python script with unexpected exception."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "except-skill",
+                """---
+name: except-skill
+description: Exception test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "crash.py", "content": "raise RuntimeError"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=RuntimeError("Unexpected"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(RuntimeError, match="Unexpected"):
+                manager.run_skill_script("except-skill", "scripts/crash.py")
+
+    def test_run_shell_script_timeout(self, mocker):
+        """Test running shell script that times out."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-timeout-skill",
+                """---
+name: sh-timeout-skill
+description: Shell timeout test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "slow.sh", "content": "#!/bin/bash\nsleep 1000"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("cmd", 300))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(TimeoutError, match="timed out"):
+                manager.run_skill_script("sh-timeout-skill", "scripts/slow.sh")
+
+    def test_run_shell_script_error_returns_json(self, mocker):
+        """Test running shell script that returns error code."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-error-skill",
+                """---
+name: sh-error-skill
+description: Shell error test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "fail.sh", "content": "#!/bin/bash\nexit 1"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 1
+            mock_result.stdout = "partial output"
+            mock_result.stderr = "Shell error"
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script("sh-error-skill", "scripts/fail.sh")
+
+            parsed = json.loads(result)
+            assert "error" in parsed
+
+
+class TestSkillManagerGetSkillFileTree:
+    """Test SkillManager.get_skill_file_tree edge cases."""
+
+    def test_get_file_tree_ignores_skill_md_in_subdirs(self):
+        """Test that SKILL.md in subdirectories is ignored."""
+        with TempSkillDir() as temp:
+            skill_dir = os.path.join(temp.skills_dir, "md-subdir-skill")
+            os.makedirs(skill_dir)
+
+            with open(os.path.join(skill_dir, "SKILL.md"), "w") as f:
+                f.write("---\nname: md-subdir-skill\ndescription: Test\n---\n# Content\n")
+
+            subdir = os.path.join(skill_dir, "data")
+            os.makedirs(subdir)
+            with open(os.path.join(subdir, "SKILL.md"), "w") as f:
+                f.write("# This should be ignored\n")
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.get_skill_file_tree("md-subdir-skill")
+
+            assert result is not None
+
+            def count_skill_md(node):
+                count = 0
+                for child in node.get("children", []):
+                    if child["name"] == "SKILL.md":
+                        count += 1
+                    if child["type"] == "directory":
+                        count += count_skill_md(child)
+                return count
+
+            # Should only have one SKILL.md at root
+            assert count_skill_md(result) == 1
+
+
+class TestSkillManagerListSkills:
+    """Test SkillManager.list_skills error handling."""
+
+    def test_list_skills_with_os_error(self, mocker):
+        """Test listing skills when os.listdir raises OSError."""
+        with TempSkillDir() as temp:
+            mocker.patch("os.listdir", side_effect=OSError("Permission denied"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.list_skills()
+
+            # Should return empty list and log error
+            assert result == []
+
+    def test_list_skills_with_load_error(self, mocker):
+        """Test listing skills when loading a skill raises exception."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "load-error-skill",
+                """---
+name: load-error-skill
+description: Test
+---
+# Content
+""",
+            )
+
+            mocker.patch.object(
+                module_manager.SkillManager,
+                "load_skill",
+                side_effect=Exception("Load failed")
+            )
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.list_skills()
+
+            # Should skip the failing skill
+            assert result == []
+
+
+class TestSkillManagerUploadSkillEnhanced:
+    """Enhanced tests for SkillManager.upload_skill_from_file."""
+
+    def test_upload_zip_with_directory_entries_skipped(self):
+        """Test ZIP directory entries (ending with '/') are skipped."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("dir-skill/SKILL.md", """---
+name: dir-skill
+description: With directories
+---
+# Content
+""")
+                zf.writestr("dir-skill/data/config.json", '{"key": "value"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "dir-skill"
+            skill_dir = os.path.join(temp.skills_dir, "dir-skill")
+            assert os.path.exists(os.path.join(skill_dir, "data", "config.json"))
+
+    def test_upload_zip_nested_skill_md_fallback(self):
+        """Test ZIP with deeply nested SKILL.md triggers fallback search."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("nested-skill/SKILL.md", """---
+name: nested-skill
+description: Nested path
+---
+# Content
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            assert result["name"] == "nested-skill"
+
+    def test_upload_zip_parse_exception_raised(self):
+        """Test ZIP with invalid SKILL.md content raises ValueError."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("bad-skill/SKILL.md", """---
+name: bad-skill
+---
+invalid: !!python/object/apply:os.system
+""")
+
+            zip_bytes = zip_buffer.getvalue()
+
+            with pytest.raises(ValueError, match="Failed to parse SKILL.md"):
+                manager.upload_skill_from_file(zip_bytes)
+
+    def test_upload_zip_extracts_different_prefix_files(self):
+        """Test ZIP files without skill name prefix are extracted as-is."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("prefix-skill/SKILL.md", """---
+name: prefix-skill
+description: Prefix test
+---
+# Content
+""")
+                zf.writestr("other-prefix/data.json", '{"other": true}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.upload_skill_from_file(zip_bytes)
+
+            assert result is not None
+            skill_dir = os.path.join(temp.skills_dir, "prefix-skill")
+            assert os.path.exists(os.path.join(skill_dir, "other-prefix", "data.json"))
+
+
+class TestSkillManagerUpdateSkillEnhanced:
+    """Enhanced tests for SkillManager.update_skill_from_file."""
+
+    def test_update_zip_skips_skill_md_when_not_found(self):
+        """Test ZIP update skips SKILL.md when not present in ZIP."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "no-md-update",
+                """---
+name: no-md-update
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("no-md-update/config.json", '{"updated": true}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "no-md-update")
+
+            assert result is not None
+
+    def test_update_zip_extracts_different_prefix_files(self):
+        """Test ZIP update extracts files with different folder prefix."""
+        with TempSkillDir() as temp:
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            temp.create_skill(
+                "prefix-update",
+                """---
+name: prefix-update
+description: Original
+---
+# Original
+""",
+            )
+
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr("prefix-update/SKILL.md", """---
+name: prefix-update
+description: Updated
+---
+# Updated
+""")
+                zf.writestr("other-prefix/data.json", '{"key": "value"}')
+
+            zip_bytes = zip_buffer.getvalue()
+            result = manager.update_skill_from_file(zip_bytes, "prefix-update")
+
+            assert result is not None
+
+
+class TestSkillManagerAddToTreeEnhanced:
+    """Enhanced tests for SkillManager._add_to_tree method."""
+
+    def test_add_to_tree_reuses_existing_directory(self):
+        """Test adding path reuses existing directory node."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "dir1", "type": "directory", "children": []}]}
+
+        manager._add_to_tree(node, ["dir1", "file.txt"], is_directory=False)
+
+        assert len(node["children"]) == 1
+        assert node["children"][0]["children"][0]["name"] == "file.txt"
+
+    def test_add_to_tree_skips_type_conflict(self):
+        """Test type conflict skips adding the entry."""
+        manager = SkillManager()
+        node = {"name": "root", "type": "directory", "children": [{"name": "conflict", "type": "directory", "children": []}]}
+
+        manager._add_to_tree(node, ["conflict"], is_directory=False)
+
+        assert len(node["children"]) == 1
+
+
+class TestSkillManagerErrorHandlingEnhanced:
+    """Enhanced error handling tests for SkillManager."""
+
+    def test_cleanup_handles_rmtree_exception(self, mocker):
+        """Test cleanup logs warning when rmtree fails."""
+        mocker.patch("os.listdir", return_value=[f"skill_test_cleanup"])
+        mocker.patch("os.path.isdir", return_value=True)
+        mocker.patch("shutil.rmtree", side_effect=OSError("Access denied"))
+
+        manager = SkillManager(local_skills_dir="/fake")
+        manager.cleanup_skill_directory("test-cleanup")
+
+    def test_run_python_script_with_list_params(self, mocker):
+        """Test running Python script with list parameter."""
+        import subprocess
+        from unittest.mock import ANY
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "list-param-skill",
+                """---
+name: list-param-skill
+description: List param test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "multi.py", "content": "print('ok')"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 0
+            mock_result.stdout = "ok"
+            mock_result.stderr = ""
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script(
+                "list-param-skill",
+                "scripts/multi.py",
+                params={"-i": ["a", "b", "c"]}
+            )
+
+            assert result == "ok"
+            args = subprocess.run.call_args[0][0]
+            assert args == ["python", ANY, "-i", "a", "-i", "b", "-i", "c"]
+
+    def test_run_python_script_boolean_false_excluded(self, mocker):
+        """Test boolean False params are excluded from args."""
+        import subprocess
+
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "bool-false-skill",
+                """---
+name: bool-false-skill
+description: Bool false test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "bool.py", "content": "print('ok')"}],
+                },
+            )
+
+            mock_result = MagicMock()
+            mock_result.returncode = 0
+            mock_result.stdout = "ok"
+            mock_result.stderr = ""
+
+            mocker.patch("subprocess.run", return_value=mock_result)
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+            result = manager.run_skill_script(
+                "bool-false-skill",
+                "scripts/bool.py",
+                params={"--quiet": False, "--verbose": True}
+            )
+
+            args = subprocess.run.call_args[0][0]
+            assert "--quiet" not in args
+            assert "--verbose" in args
+
+    def test_run_shell_script_other_exception(self, mocker):
+        """Test shell script with unexpected exception propagates."""
+        with TempSkillDir() as temp:
+            temp.create_skill(
+                "sh-except-skill",
+                """---
+name: sh-except-skill
+description: Shell exception test
+---
+# Content
+""",
+                subdirs={
+                    "scripts": [{"name": "except.sh", "content": "#!/bin/bash\nthrow"}],
+                },
+            )
+
+            mocker.patch("subprocess.run", side_effect=RuntimeError("Unexpected shell error"))
+
+            manager = SkillManager(local_skills_dir=temp.skills_dir)
+
+            with pytest.raises(RuntimeError, match="Unexpected shell error"):
+                manager.run_skill_script("sh-except-skill", "scripts/except.sh")
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])