langchain-agentx-python 0.1__py3-none-any.whl

langchain_agentx/tools/bash/windows_shell_quoting.py

@@ -0,0 +1,45 @@
+"""
+windows_shell_quoting.py — Windows CMD 风格重定向纠偏（POSIX shell 内）
+
+职责：
+    将误入 Git Bash 的 **`>nul` / `2>nul` / `&>nul`** 等改写为 **`/dev/null`**，避免在当前目录
+    生成保留名 **`nul`** 文件（与 CC `utils/bash/shellQuoting.ts::rewriteWindowsNullRedirect` 同思路）。
+
+链路位置：
+    `BashBackend` 在把用户 `command` 拼进 `-c` 包装脚本 **之前** 调用 **`rewrite_windows_null_redirect`**。
+
+当前裁剪范围：
+    不解析引号内字面量（与 CC 一致：极少数误伤可接受）；非 win32 默认整段 **no-op**。
+
+参考：
+    anthropics/claude-code 相关 issue（`nul` 保留设备名、`shellQuoting`）；设计 SSOT
+    docs/design-docs/tool-design/bash-tool-cross-platform.md Phase 3。
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+# 与 CC 描述对齐：可选 fd、`&`、`>` 重复、空白，后跟 **nul** 整词（排除 `null`、`nul.txt` 等）。
+# 前瞻：nul 后须为分隔/行尾/管道等，避免匹配 `nul.txt` 中的 `nul`。
+_NUL_REDIRECT_RE = re.compile(
+    r"(\d?&?>+)\s*nul(?=\s|$|[|&;)'\"`]|\\|\n|\r)",
+    re.IGNORECASE,
+)
+
+
+def rewrite_windows_null_redirect(
+    command: str,
+    *,
+    _platform: str | None = None,
+) -> str:
+    """
+    将 CMD 风格 `nul` 重定向改为 `/dev/null`。
+
+    `_platform` 仅供单测注入；默认使用 **`sys.platform`**（仅 **`win32`** 时改写）。
+    """
+    plat = sys.platform if _platform is None else _platform
+    if plat != "win32":
+        return command
+    return _NUL_REDIRECT_RE.sub(r"\1/dev/null", command)

langchain_agentx/tools/glob/__init__.py

@@ -0,0 +1,9 @@
+"""
+tools/glob — GlobRuntimeTool 包
+
+GlobRuntimeTool 是工具体系 P2 只读搜索工具，负责按文件名模式匹配路径。
+"""
+
+from .tool import GlobRuntimeTool
+
+__all__ = ["GlobRuntimeTool"]

langchain_agentx/tools/glob/models.py

@@ -0,0 +1,57 @@
+"""
+tools/glob/models.py — GlobToolInput / GlobToolOutput
+
+职责：
+    定义 glob 工具面向模型暴露的输入 schema，以及 invoke() 返回的内部输出结构。
+
+对应 CC：
+    src/tools/GlobTool/GlobTool.ts 中的 inputSchema / outputSchema；
+    offset + limit 分页语义对齐 src/utils/glob.ts（v2-C）。
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+DEFAULT_MAX_RESULTS = 100
+MAX_MAX_RESULTS = 1_000
+
+
+class GlobToolInput(BaseModel):
+    pattern: str = Field(
+        ...,
+        description=(
+            "The glob pattern to match files against. Semantics follow ripgrep --glob "
+            '(same family as the grep tool file filter), e.g. "**/*.py", "src/**/*.ts".'
+        ),
+    )
+    path: str | None = Field(
+        default=None,
+        description=(
+            "The directory to search in. If omitted, the workspace root is used. "
+            'Do not pass "null" or "undefined"; simply omit this field.'
+        ),
+    )
+    offset: int = Field(
+        default=0,
+        ge=0,
+        description=(
+            "Skip this many matches from the start of the sorted result list "
+            "(same semantics as CC globLimits offset; pairs with the tool's max_results limit)."
+        ),
+    )
+
+
+class GlobToolOutput(BaseModel):
+    """工具内部结果，供 present() 映射为 ToolResultEnvelope。"""
+
+    model_config = {"extra": "forbid"}
+
+    pattern: str
+    search_root: str
+    filenames: list[str] = Field(default_factory=list)
+    num_files: int = 0
+    truncated: bool = False
+    total_matches: int = 0
+    offset: int = 0
+    duration_ms: float = 0.0

langchain_agentx/tools/glob/pagination.py

@@ -0,0 +1,30 @@
+"""
+tools/glob/pagination.py — 有序路径列表上的 offset/limit 分页
+
+职责：
+    在已排序的全量路径列表上执行与 CC `utils/glob.ts` 一致的 slice 与 truncated 判定。
+
+在整体链路中的位置：
+    GlobRuntimeTool.invoke() 在 list_files_via_ripgrep 返回全量列表后调用本模块。
+
+当前裁剪范围：
+    仅 slice + truncated 布尔；不包含流式截断或磁盘 walk。
+"""
+
+from __future__ import annotations
+
+
+def slice_glob_paths(
+    paths: list[str],
+    *,
+    offset: int,
+    limit: int,
+) -> tuple[list[str], int, bool]:
+    """
+    与 CC 一致：``truncated = len(paths) > offset + limit``，
+    返回 ``paths[offset : offset + limit]``。
+    """
+    total = len(paths)
+    end = offset + max(1, limit)
+    truncated = total > end
+    return paths[offset:end], total, truncated

langchain_agentx/tools/glob/prompt.py

@@ -0,0 +1,24 @@
+"""
+tools/glob/prompt.py — 工具名与模型可见描述
+
+对应 CC：
+    src/tools/GlobTool/prompt.ts。
+"""
+
+from __future__ import annotations
+
+TOOL_NAME = "glob"
+
+
+def get_prompt() -> str:
+    return (
+        "- Fast file pattern matching tool that works with any codebase size\n"
+        '- Supports glob patterns like "**/*.js" or "src/**/*.ts"\n'
+        "- Returns matching file paths sorted by modification time\n"
+        "- Use this tool when you need to find files by name patterns\n"
+        "- When you are doing an open ended search that may require multiple rounds "
+        "of globbing and grepping, use the Agent tool instead"
+    )
+
+
+DESCRIPTION = get_prompt()

langchain_agentx/tools/glob/rg_list_backend.py

@@ -0,0 +1,139 @@
+"""
+tools/glob/rg_list_backend.py — rg --files 列路径（对齐 CC utils/glob.ts）
+
+职责：拼装与 CC 一致的 ripgrep 参数并调用 run_ripgrep_lines。
+链路：GlobRuntimeTool.invoke -> list_files_via_ripgrep -> run_ripgrep_lines。
+
+裁剪：plugin cache 排除由调用方传入 `plugin_glob_exclusions`（与 CC glob.ts 追加顺序一致）。
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+
+from langchain_agentx.tools.grep.backend import RipgrepBackend, run_ripgrep_lines
+from langchain_agentx.utils.subprocess_text import (
+    TextSubprocessRunner,
+    default_text_subprocess_runner,
+)
+
+
+def _read_cc_style_flag(*, langchain_key: str, cc_key: str) -> bool:
+    v = os.environ.get(langchain_key)
+    if v is None:
+        v = os.environ.get(cc_key, "1")
+    return v.strip().lower() not in ("", "0", "false", "no", "off")
+
+
+def _ignore_patterns_to_rg_globs(ignore_patterns: list[str] | None) -> list[str]:
+    out: list[str] = []
+    if not ignore_patterns:
+        return out
+    for p in ignore_patterns:
+        p = str(p).strip()
+        if not p:
+            continue
+        rg_pat = f"!{p}" if p.startswith("/") else f"!**/{p}"
+        out.extend(["--glob", rg_pat])
+    return out
+
+
+def build_rg_files_args(
+    relative_glob: str,
+    *,
+    no_ignore: bool | None = None,
+    hidden: bool | None = None,
+    ignore_patterns: list[str] | None = None,
+    plugin_glob_exclusions: list[str] | None = None,
+) -> list[str]:
+    """
+    对齐 CC glob.ts：--files --glob <pattern> --sort=modified，及默认 --no-ignore / --hidden。
+    环境变量（与 CC 名称兼容，便于本机已有配置）：
+      CLAUDE_CODE_GLOB_NO_IGNORE / LANGCHAIN_AGENTX_GLOB_NO_IGNORE
+      CLAUDE_CODE_GLOB_HIDDEN / LANGCHAIN_AGENTX_GLOB_HIDDEN
+    未设置时默认 true（与 CC 一致）。
+    """
+    if no_ignore is None:
+        no_ignore = _read_cc_style_flag(
+            langchain_key="LANGCHAIN_AGENTX_GLOB_NO_IGNORE",
+            cc_key="CLAUDE_CODE_GLOB_NO_IGNORE",
+        )
+    if hidden is None:
+        hidden = _read_cc_style_flag(
+            langchain_key="LANGCHAIN_AGENTX_GLOB_HIDDEN",
+            cc_key="CLAUDE_CODE_GLOB_HIDDEN",
+        )
+
+    args: list[str] = [
+        "--files",
+        "--glob",
+        relative_glob,
+        "--sort=modified",
+    ]
+    if no_ignore:
+        args.append("--no-ignore")
+    if hidden:
+        args.append("--hidden")
+    for d in RipgrepBackend.VCS_EXCLUDE_DIRS:
+        args.extend(["--glob", f"!{d}"])
+    args.extend(_ignore_patterns_to_rg_globs(ignore_patterns))
+    if plugin_glob_exclusions:
+        for ex in plugin_glob_exclusions:
+            if ex:
+                args.extend(["--glob", ex])
+    return args
+
+
+def list_files_via_ripgrep(
+    search_root: str,
+    relative_glob: str,
+    *,
+    rg_path: str,
+    timeout: int,
+    ignore_patterns: list[str] | None = None,
+    plugin_glob_exclusions: list[str] | None = None,
+    text_runner: TextSubprocessRunner | None = None,
+    cancel_event: threading.Event | None = None,
+) -> list[str]:
+    """
+    在 search_root 下执行 rg，返回**绝对路径**列表（仅文件），路径已 normpath。
+    stdout 行为与 CC 一致：相对 search_root 的相对路径。
+    """
+    runner = text_runner or default_text_subprocess_runner()
+    args = build_rg_files_args(
+        relative_glob,
+        ignore_patterns=ignore_patterns,
+        plugin_glob_exclusions=plugin_glob_exclusions,
+    )
+    lines = run_ripgrep_lines(
+        rg_path,
+        args,
+        search_root,
+        timeout=timeout,
+        text_runner=runner,
+        is_retry=False,
+        cancel_event=cancel_event,
+    )
+    root = os.path.realpath(search_root)
+    files: list[str] = []
+    seen: set[str] = set()
+    for ln in lines:
+        p = ln.strip()
+        if not p:
+            continue
+        full = os.path.normpath(p if os.path.isabs(p) else os.path.join(root, p))
+        if full in seen:
+            continue
+        if os.path.isfile(full):
+            seen.add(full)
+            files.append(full)
+    # 对齐 CC：--sort=modified 升序；同 mtime 时按路径稳定次序
+    def _mtime_key(path: str) -> tuple[float, str]:
+        try:
+            return (os.path.getmtime(path), path)
+        except OSError:
+            return (0.0, path)
+
+    files.sort(key=_mtime_key)
+    return files

langchain_agentx/tools/glob/rg_pattern.py

@@ -0,0 +1,44 @@
+"""
+tools/glob/rg_pattern.py — 绝对 glob pattern 拆分为搜索根 + 相对 rg --glob
+
+职责：移植 CC src/utils/glob.ts 的 extractGlobBaseDirectory，供 Glob 与 rg --glob 对齐。
+链路：GlobRuntimeTool.invoke -> extract_glob_base_directory。
+
+裁剪：仅服务于本工具路径语义；不含 CC 的 getPlatform 以外的逻辑。
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+
+def extract_glob_base_directory(pattern: str) -> tuple[str, str]:
+    """
+    返回 (base_dir, relative_pattern)。
+    ripgrep 的 --glob 在作为「目录扫描」参数链中需配合「相对 pattern」使用，与 CC 一致。
+    """
+    sep = os.sep
+    glob_chars = re.compile(r"[*?[{]")
+    match = glob_chars.search(pattern)
+    if not match:
+        d = os.path.dirname(pattern)
+        f = os.path.basename(pattern)
+        return (d, f)
+
+    static_prefix = pattern[: match.start()]
+    last_sep = max(static_prefix.rfind("/"), static_prefix.rfind("\\"))
+    if last_sep < 0:
+        return ("", pattern)
+
+    base_dir = static_prefix[:last_sep]
+    relative_pattern = pattern[last_sep + 1 :]
+
+    if base_dir == "" and last_sep == 0:
+        base_dir = "/"
+
+    if sys.platform == "win32" and len(base_dir) == 2 and base_dir[1] == ":" and base_dir[0].isalpha():
+        base_dir = base_dir + sep
+
+    return (base_dir, relative_pattern)

langchain_agentx/tools/glob/tool.py

@@ -0,0 +1,327 @@
+"""
+职责：
+    GlobRuntimeTool — 按文件名模式列路径（系统 ripgrep：`rg --files`，对齐 CC utils/glob.ts）。
+    实现 RuntimeTool 生命周期；不负责读文件内容（Read）与内容搜索（Grep）。
+
+在整体链路中的位置：
+    ToolExecutorPipeline -> GlobRuntimeTool.invoke()
+    -> rg_list_backend.list_files_via_ripgrep(..., cancel_event=ctx.cancel_event)
+    -> GlobToolOutput -> after_invoke（可选写入 ToolStateBridge.last_glob_summary）
+    -> present() -> ToolResultEnvelope
+
+与 CC 对照：
+    对应 CC src/tools/GlobTool/GlobTool.ts + src/utils/glob.ts。
+    仅使用系统 PATH 中的 ripgrep：Windows 默认 `rg.exe`，Unix 默认 `rg`（见 utils.rg_executable）。
+    validate_input 对 UNC / ``//`` 前缀跳过本地 stat，与 CC 一致（utils.unc_path）。
+    不使用 Python 标准库 glob，避免与 ripgrep --glob 两套语法。
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any
+
+from langchain_agentx.tool_runtime.base import RuntimeTool
+from langchain_agentx.tool_runtime.models import (
+    AuthorizationDecision,
+    ToolExecutionContext,
+    ToolHint,
+    ToolResultEnvelope,
+    ValidationResult,
+)
+from langchain_agentx.tool_runtime.state_bridge import ToolStateBridge
+from langchain_agentx.tools.grep.backend import GrepExecutionError, RipgrepBackend
+from langchain_agentx.tools.ripgrep_plugin_exclusions import PluginCacheGlobExclusions
+from langchain_agentx.utils.path_user_input import UserPathInputNormalizer
+from langchain_agentx.utils.rg_executable import default_rg_executable
+from langchain_agentx.utils.unc_path import is_unc_path_skip_local_stat
+
+from .models import DEFAULT_MAX_RESULTS, MAX_MAX_RESULTS, GlobToolInput, GlobToolOutput
+from .pagination import slice_glob_paths
+from .prompt import DESCRIPTION, TOOL_NAME
+from .rg_list_backend import list_files_via_ripgrep
+from .rg_pattern import extract_glob_base_directory
+
+
+def _has_path_traversal(pattern: str) -> bool:
+    normalized = pattern.replace("\\", "/")
+    parts = [part for part in normalized.split("/") if part]
+    return any(part == ".." for part in parts)
+
+
+def _is_descendant(child: str, parent: str) -> bool:
+    try:
+        c = os.path.realpath(child)
+        p = os.path.realpath(parent)
+        return os.path.commonpath([c, p]) == p
+    except ValueError:
+        return False
+
+
+class GlobRuntimeTool(RuntimeTool):
+    name: str = TOOL_NAME
+    description: str = DESCRIPTION
+    input_model = GlobToolInput
+    output_model = GlobToolOutput
+
+    is_read_only: bool = True
+    is_concurrency_safe: bool = True
+    never_truncate: bool = False
+    dedupe_identical_calls: bool = True
+    max_result_size_chars: int = 100_000
+
+    def __init__(
+        self,
+        *,
+        workspace_root: str,
+        max_results: int = DEFAULT_MAX_RESULTS,
+        policy: Any | None = None,
+        state_bridge: Any | None = None,
+        path_normalizer: UserPathInputNormalizer | None = None,
+        rg_path: str | None = None,
+        rg_timeout: int = RipgrepBackend.DEFAULT_TIMEOUT,
+        ignore_patterns: list[str] | None = None,
+        plugin_cache_glob_exclusions: PluginCacheGlobExclusions | None = None,
+    ) -> None:
+        super().__init__(policy=policy, state_bridge=state_bridge)
+        self._workspace_root = os.path.realpath(os.path.expanduser(workspace_root))
+        self.max_results = max(1, min(int(max_results), MAX_MAX_RESULTS))
+        self._path_normalizer = path_normalizer or UserPathInputNormalizer()
+        self._rg_path = rg_path if rg_path is not None else default_rg_executable()
+        self._rg_timeout = int(rg_timeout)
+        self._ignore_patterns = [p for p in (ignore_patterns or []) if str(p).strip()]
+        self._plugin_cache_glob_exclusions = plugin_cache_glob_exclusions
+
+    def normalize_input(
+        self,
+        raw: dict[str, Any],
+        ctx: ToolExecutionContext,
+    ) -> dict[str, Any]:
+        data = dict(raw)
+        pattern = data.get("pattern")
+        if isinstance(pattern, str):
+            data["pattern"] = pattern.strip()
+
+        path = data.get("path")
+        from langchain_agentx.utils.cwd import get_cwd
+
+        if isinstance(path, str) and path.strip():
+            data["path"] = self._path_normalizer.normalize_and_expand(
+                path, base_dir=ctx.cwd
+            )
+        else:
+            data["path"] = ctx.cwd or get_cwd()
+        return data
+
+    def validate_input(
+        self,
+        data: dict[str, Any],
+        ctx: ToolExecutionContext,
+    ) -> ValidationResult:
+        pattern = str(data.get("pattern") or "").strip()
+        if not pattern:
+            return ValidationResult(
+                ok=False,
+                message="Pattern cannot be empty",
+                code="EMPTY_PATTERN",
+            )
+        if _has_path_traversal(pattern):
+            return ValidationResult(
+                ok=False,
+                message="Pattern must not contain path traversal sequences",
+                code="PATH_TRAVERSAL",
+            )
+
+        search_root = str(data["path"])
+        # CC validateInput：UNC / // 前缀跳过本地 stat（与 Grep 一致）
+        if is_unc_path_skip_local_stat(search_root):
+            return ValidationResult(ok=True)
+        if not os.path.exists(search_root):
+            return ValidationResult(
+                ok=False,
+                message=(
+                    f"Directory does not exist: {search_root}. "
+                    f"Current workspace: {self._workspace_root}"
+                ),
+                code="DIR_NOT_FOUND",
+            )
+        if not os.path.isdir(search_root):
+            return ValidationResult(
+                ok=False,
+                message=f"Path is not a directory: {search_root}",
+                code="NOT_A_DIRECTORY",
+            )
+        return ValidationResult(ok=True)
+
+    def check_permissions(
+        self,
+        data: dict[str, Any],
+        ctx: ToolExecutionContext,
+    ) -> AuthorizationDecision:
+        return super().check_permissions(data, ctx)
+
+    def after_invoke(
+        self,
+        data: dict[str, Any],
+        result: Any,
+        ctx: ToolExecutionContext,
+    ) -> None:
+        """
+        v2-D：若构造时注入 ``ToolStateBridge``，将本次 Glob 摘要写入 ``ctx.state``
+        （供 ``get_last_glob_summary`` 读取；**不**参与 PolicyEngine）。
+        """
+        if self._state_bridge is None or not isinstance(self._state_bridge, ToolStateBridge):
+            return
+        if not isinstance(result, GlobToolOutput):
+            return
+        self._state_bridge.record_last_glob(
+            ctx,
+            pattern=result.pattern,
+            search_root=result.search_root,
+            filenames=result.filenames,
+            num_files_page=result.num_files,
+            total_matches=result.total_matches,
+            truncated=result.truncated,
+            offset=result.offset,
+        )
+
+    def invoke(
+        self,
+        data: dict[str, Any],
+        ctx: ToolExecutionContext,
+    ) -> GlobToolOutput:
+        pattern = str(data["pattern"])
+        search_root = os.path.realpath(str(data["path"]))
+        started = time.perf_counter()
+
+        relative_glob = pattern
+        if os.path.isabs(pattern):
+            base_dir, relative_glob = extract_glob_base_directory(pattern)
+            if base_dir:
+                candidate = os.path.realpath(os.path.expanduser(base_dir))
+                if not _is_descendant(candidate, self._workspace_root):
+                    raise GrepExecutionError(
+                        "Glob pattern resolves to a directory outside the workspace root."
+                    )
+                search_root = candidate
+
+        plugin_ex: list[str] | None = None
+        if self._plugin_cache_glob_exclusions is not None:
+            plugin_ex = self._plugin_cache_glob_exclusions.get_exclusions_for_search(
+                search_root
+            )
+            if not plugin_ex:
+                plugin_ex = None
+
+        try:
+            files_full = list_files_via_ripgrep(
+                search_root,
+                relative_glob,
+                rg_path=self._rg_path,
+                timeout=self._rg_timeout,
+                ignore_patterns=self._ignore_patterns or None,
+                plugin_glob_exclusions=plugin_ex,
+                cancel_event=ctx.cancel_event,
+            )
+        except GrepExecutionError:
+            raise
+        except OSError as e:
+            raise GrepExecutionError(f"Glob failed while resolving paths: {e}") from e
+
+        page_offset = int(data["offset"])
+        files, total_matches, truncated = slice_glob_paths(
+            files_full,
+            offset=page_offset,
+            limit=self.max_results,
+        )
+        relative_files = [self._to_relative(path) for path in files]
+
+        duration_ms = (time.perf_counter() - started) * 1000.0
+        return GlobToolOutput(
+            pattern=pattern,
+            search_root=search_root,
+            filenames=relative_files,
+            num_files=len(relative_files),
+            truncated=truncated,
+            total_matches=total_matches,
+            offset=page_offset,
+            duration_ms=duration_ms,
+        )
+
+    def present(
+        self,
+        data: dict[str, Any],
+        result: Any,
+        ctx: ToolExecutionContext,
+    ) -> ToolResultEnvelope:
+        if not isinstance(result, GlobToolOutput):
+            return ToolResultEnvelope(
+                status="ok",
+                tool_name=self.name,
+                summary=str(result),
+                payload=str(result),
+            )
+
+        meta = {
+            "pattern": result.pattern,
+            "search_root": result.search_root,
+            "num_files": result.num_files,
+            "truncated": result.truncated,
+            "total_matches": result.total_matches,
+            "offset": result.offset,
+            "duration_ms": round(result.duration_ms, 2),
+            "glob_backend": "ripgrep",
+        }
+
+        if result.num_files == 0:
+            if result.total_matches == 0:
+                summary = "No files found"
+            else:
+                summary = (
+                    f"No files in this page (offset {result.offset}, "
+                    f"{result.total_matches} total match(es))"
+                )
+            return ToolResultEnvelope(
+                status="ok",
+                tool_name=self.name,
+                summary=summary,
+                payload={
+                    "filenames": [],
+                    "num_files": 0,
+                    "truncated": result.truncated,
+                    "total_matches": result.total_matches,
+                    "offset": result.offset,
+                },
+                meta=meta,
+            )
+
+        summary = f"Found {result.num_files} file(s) matching '{result.pattern}'"
+        payload_lines = list(result.filenames)
+        hints: list[ToolHint] | None = None
+        if result.truncated:
+            summary += (
+                f" (results truncated at {self.max_results}"
+                + (f", offset {result.offset}" if result.offset else "")
+                + ")"
+            )
+            hint_msg = (
+                "Results are truncated. Consider using a more specific path or pattern."
+            )
+            payload_lines.append(f"({hint_msg})")
+            hints = [ToolHint(message=hint_msg)]
+
+        return ToolResultEnvelope(
+            status="ok",
+            tool_name=self.name,
+            summary=summary,
+            payload="\n".join(payload_lines),
+            hints=hints,
+            meta=meta,
+        )
+
+    def _to_relative(self, path: str) -> str:
+        try:
+            return os.path.relpath(path, self._workspace_root)
+        except ValueError:
+            return path

langchain_agentx/tools/grep/__init__.py

@@ -0,0 +1,7 @@
+"""GrepRuntimeTool — 基于 ripgrep 的内容搜索。"""
+
+from __future__ import annotations
+
+from .tool import GrepRuntimeTool
+
+__all__ = ["GrepRuntimeTool"]