kimi-cli 0.35__py3-none-any.whl → 0.52__py3-none-any.whl

kimi_cli/soul/runtime.py

@@ -0,0 +1,96 @@
+import asyncio
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import NamedTuple
+
+from kimi_cli.config import Config
+from kimi_cli.llm import LLM
+from kimi_cli.session import Session
+from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.denwarenji import DenwaRenji
+from kimi_cli.utils.logging import logger
+
+
+class BuiltinSystemPromptArgs(NamedTuple):
+    """Builtin system prompt arguments."""
+
+    KIMI_NOW: str
+    """The current datetime."""
+    KIMI_WORK_DIR: Path
+    """The current working directory."""
+    KIMI_WORK_DIR_LS: str
+    """The directory listing of current working directory."""
+    KIMI_AGENTS_MD: str  # TODO: move to first message from system prompt
+    """The content of AGENTS.md."""
+
+
+def load_agents_md(work_dir: Path) -> str | None:
+    paths = [
+        work_dir / "AGENTS.md",
+        work_dir / "agents.md",
+    ]
+    for path in paths:
+        if path.is_file():
+            logger.info("Loaded agents.md: {path}", path=path)
+            return path.read_text(encoding="utf-8").strip()
+    logger.info("No AGENTS.md found in {work_dir}", work_dir=work_dir)
+    return None
+
+
+def _list_work_dir(work_dir: Path) -> str:
+    if sys.platform == "win32":
+        ls = subprocess.run(
+            ["cmd", "/c", "dir", work_dir],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    else:
+        ls = subprocess.run(
+            ["ls", "-la", work_dir],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    return ls.stdout.strip()
+
+
+class Runtime(NamedTuple):
+    """Agent runtime."""
+
+    config: Config
+    llm: LLM | None
+    session: Session
+    builtin_args: BuiltinSystemPromptArgs
+    denwa_renji: DenwaRenji
+    approval: Approval
+
+    @staticmethod
+    async def create(
+        config: Config,
+        llm: LLM | None,
+        session: Session,
+        yolo: bool,
+    ) -> "Runtime":
+        ls_output, agents_md = await asyncio.gather(
+            asyncio.to_thread(_list_work_dir, session.work_dir),
+            asyncio.to_thread(load_agents_md, session.work_dir),
+        )
+
+        return Runtime(
+            config=config,
+            llm=llm,
+            session=session,
+            builtin_args=BuiltinSystemPromptArgs(
+                KIMI_NOW=datetime.now().astimezone().isoformat(),
+                KIMI_WORK_DIR=session.work_dir,
+                KIMI_WORK_DIR_LS=ls_output,
+                KIMI_AGENTS_MD=agents_md or "",
+            ),
+            denwa_renji=DenwaRenji(),
+            approval=Approval(yolo=yolo),
+        )

kimi_cli/soul/toolset.py

@@ -1,8 +1,9 @@
 from contextvars import ContextVar
 from typing import override
 
-from kosong.base.message import ToolCall
-from kosong.tooling import HandleResult, SimpleToolset
+from kosong.message import ToolCall
+from kosong.tooling import HandleResult
+from kosong.tooling.simple import SimpleToolset
 
 current_tool_call = ContextVar[ToolCall | None]("current_tool_call", default=None)
 

kimi_cli/tools/__init__.py

@@ -1,81 +1,85 @@
 import json
 from pathlib import Path
+from typing import cast
 
-import streamingjson
+import streamingjson  # pyright: ignore[reportMissingTypeStubs]
 from kosong.utils.typing import JsonType
 
 from kimi_cli.utils.string import shorten_middle
 
 
-def extract_subtitle(lexer: streamingjson.Lexer, tool_name: str) -> str | None:
+class SkipThisTool(Exception):
+    """Raised when a tool decides to skip itself from the loading process."""
+
+    pass
+
+
+def extract_key_argument(json_content: str | streamingjson.Lexer, tool_name: str) -> str | None:
+    if isinstance(json_content, streamingjson.Lexer):
+        json_str = json_content.complete_json()
+    else:
+        json_str = json_content
     try:
-        curr_args: JsonType = json.loads(lexer.complete_json())
+        curr_args: JsonType = json.loads(json_str)
     except json.JSONDecodeError:
         return None
     if not curr_args:
         return None
-    subtitle: str = ""
+    key_argument: str = ""
     match tool_name:
         case "Task":
             if not isinstance(curr_args, dict) or not curr_args.get("description"):
                 return None
-            subtitle = str(curr_args["description"])
+            key_argument = str(curr_args["description"])
         case "SendDMail":
             return "El Psy Kongroo"
         case "Think":
             if not isinstance(curr_args, dict) or not curr_args.get("thought"):
                 return None
-            subtitle = str(curr_args["thought"])
+            key_argument = str(curr_args["thought"])
         case "SetTodoList":
-            if not isinstance(curr_args, dict) or not curr_args.get("todos"):
-                return None
-            if not isinstance(curr_args["todos"], list):
-                return None
-            for todo in curr_args["todos"]:
-                if not isinstance(todo, dict) or not todo.get("title"):
-                    continue
-                subtitle += f"• {todo['title']}"
-                if todo.get("status"):
-                    subtitle += f" [{todo['status']}]"
-                subtitle += "\n"
-            return "\n" + subtitle.strip()
-        case "Bash":
+            return None
+        case "Bash" | "CMD":
             if not isinstance(curr_args, dict) or not curr_args.get("command"):
                 return None
-            subtitle = str(curr_args["command"])
+            key_argument = str(curr_args["command"])
         case "ReadFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "Glob":
             if not isinstance(curr_args, dict) or not curr_args.get("pattern"):
                 return None
-            subtitle = str(curr_args["pattern"])
+            key_argument = str(curr_args["pattern"])
         case "Grep":
             if not isinstance(curr_args, dict) or not curr_args.get("pattern"):
                 return None
-            subtitle = str(curr_args["pattern"])
+            key_argument = str(curr_args["pattern"])
         case "WriteFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "StrReplaceFile":
             if not isinstance(curr_args, dict) or not curr_args.get("path"):
                 return None
-            subtitle = _normalize_path(str(curr_args["path"]))
+            key_argument = _normalize_path(str(curr_args["path"]))
         case "SearchWeb":
             if not isinstance(curr_args, dict) or not curr_args.get("query"):
                 return None
-            subtitle = str(curr_args["query"])
+            key_argument = str(curr_args["query"])
         case "FetchURL":
             if not isinstance(curr_args, dict) or not curr_args.get("url"):
                 return None
-            subtitle = str(curr_args["url"])
+            key_argument = str(curr_args["url"])
         case _:
-            subtitle = "".join(lexer.json_content)
-    if tool_name not in ["SetTodoList"]:
-        subtitle = shorten_middle(subtitle, width=50)
-    return subtitle
+            if isinstance(json_content, streamingjson.Lexer):
+                # lexer.json_content is list[str] based on streamingjson source code
+                content: list[str] = cast(list[str], json_content.json_content)  # pyright: ignore[reportUnknownMemberType]
+                key_argument = "".join(content)
+            else:
+                key_argument = json_content
+    key_argument = shorten_middle(key_argument, width=50)
+    return key_argument
 
 
 def _normalize_path(path: str) -> str:

kimi_cli/tools/bash/__init__.py

@@ -1,6 +1,8 @@
 import asyncio
+import platform
+from collections.abc import Callable
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolReturnType
 from pydantic import BaseModel, Field
@@ -24,12 +26,16 @@ class Params(BaseModel):
     )
 
 
+_NAME = "CMD" if platform.system() == "Windows" else "Bash"
+_DESC_FILE = "cmd.md" if platform.system() == "Windows" else "bash.md"
+
+
 class Bash(CallableTool2[Params]):
-    name: str = "Bash"
-    description: str = load_desc(Path(__file__).parent / "bash.md", {})
+    name: str = _NAME
+    description: str = load_desc(Path(__file__).parent / _DESC_FILE, {})
     params: type[Params] = Params
 
-    def __init__(self, approval: Approval, **kwargs):
+    def __init__(self, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._approval = approval
 
@@ -38,16 +44,18 @@ class Bash(CallableTool2[Params]):
         builder = ToolResultBuilder()
 
         if not await self._approval.request(
-            f"run command {params.command}", f"Run command `{params.command}`"
+            self.name,
+            "run shell command",
+            f"Run command `{params.command}`",
         ):
             return ToolRejectedError()
 
         def stdout_cb(line: bytes):
-            line_str = line.decode()
+            line_str = line.decode(encoding="utf-8", errors="replace")
             builder.write(line_str)
 
         def stderr_cb(line: bytes):
-            line_str = line.decode()
+            line_str = line.decode(encoding="utf-8", errors="replace")
             builder.write(line_str)
 
         try:
@@ -69,8 +77,13 @@ class Bash(CallableTool2[Params]):
             )
 
 
-async def _stream_subprocess(command: str, stdout_cb, stderr_cb, timeout: int) -> int:
-    async def _read_stream(stream, cb):
+async def _stream_subprocess(
+    command: str,
+    stdout_cb: Callable[[bytes], None],
+    stderr_cb: Callable[[bytes], None],
+    timeout: int,
+) -> int:
+    async def _read_stream(stream: asyncio.StreamReader, cb: Callable[[bytes], None]):
         while True:
             line = await stream.readline()
             if line:
@@ -83,6 +96,9 @@ async def _stream_subprocess(command: str, stdout_cb, stderr_cb, timeout: int) -
         command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
     )
 
+    assert process.stdout is not None, "stdout is None"
+    assert process.stderr is not None, "stderr is None"
+
     try:
         await asyncio.wait_for(
             asyncio.gather(

kimi_cli/tools/bash/cmd.md

@@ -0,0 +1,31 @@
+Execute a Windows Command Prompt (`cmd.exe`) command. Use this tool to explore the filesystem, inspect or edit files, run Windows scripts, collect system information, etc., whenever the agent is running on Windows.
+
+Note that you are running on Windows, so make sure to use Windows commands, paths, and conventions.
+
+**Output:**
+The stdout and stderr streams are combined and returned as a single string. Extremely long output may be truncated. When a command fails, the exit code is provided in a system tag.
+
+**Guidelines for safety and security:**
+- Every tool call starts a fresh `cmd.exe` session. Environment variables, `cd` changes, and command history do not persist between calls.
+- Do not launch interactive programs or anything that is expected to block indefinitely; ensure each command finishes promptly. Provide a `timeout` argument for potentially long runs.
+- Avoid using `..` to leave the working directory, and never touch files outside that directory unless explicitly instructed.
+- Never attempt commands that require elevated (Administrator) privileges unless explicitly authorized.
+
+**Windows-specific tips:**
+- Use `cd /d "<path>"` when you must switch drives and directories in one command.
+- Quote any path containing spaces with double quotes. Escape special characters such as `&`, `|`, `>`, and `<` with `^` when needed.
+- Prefer non-interactive file editing techniques such as `type`, `more`, `copy`, `powershell -Command "Get-Content"`, or `python - <<'PY' ... PY`.
+- Convert forward slashes to backslashes only when a command explicitly requires it; most tooling on Windows accepts `/` as well.
+
+**Guidelines for efficiency:**
+- Chain related commands with `&&` (stop on failure) or `&` (always continue); use `||` to run a fallback after a failure.
+- Redirect or pipe output with `>`, `>>`, `|`, and leverage `for /f`, `if`, and `set` to build richer one-liners instead of multiple tool calls.
+- Reuse built-in utilities (e.g., `findstr`, `where`, `powershell`) to filter, transform, or locate data in a single invocation.
+
+**Commands available:**
+- Shell environment: `cd`, `dir`, `set`, `setlocal`, `echo`, `call`, `where`
+- File operations: `type`, `copy`, `move`, `del`, `erase`, `mkdir`, `rmdir`, `attrib`, `mklink`
+- Text/search: `find`, `findstr`, `more`, `sort`, `powershell -Command "Get-Content"`
+- System info: `ver`, `systeminfo`, `tasklist`, `wmic`, `hostname`
+- Archives/scripts: `tar`, `powershell -Command "Compress-Archive"`, `powershell`, `python`, `node`
+- Other: Any other binaries available on the system PATH; run `where <command>` first if unsure.

kimi_cli/tools/dmail/__init__.py

@@ -1,19 +1,20 @@
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 from kosong.tooling import CallableTool2, ToolError, ToolReturnType
 
 from kimi_cli.soul.denwarenji import DenwaRenji, DenwaRenjiError, DMail
+from kimi_cli.tools.utils import load_desc
 
 NAME = "SendDMail"
 
 
-class SendDMail(CallableTool2):
+class SendDMail(CallableTool2[DMail]):
     name: str = NAME
-    description: str = (Path(__file__).parent / "dmail.md").read_text()
+    description: str = load_desc(Path(__file__).parent / "dmail.md")
     params: type[DMail] = DMail
 
-    def __init__(self, denwa_renji: DenwaRenji, **kwargs):
+    def __init__(self, denwa_renji: DenwaRenji, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._denwa_renji = denwa_renji
 

kimi_cli/tools/file/__init__.py

@@ -1,9 +1,17 @@
+from enum import Enum
+
+
 class FileOpsWindow:
     """Maintains a window of file operations."""
 
     pass
 
 
+class FileActions(str, Enum):
+    READ = "read file"
+    EDIT = "edit file"
+
+
 from .glob import Glob  # noqa: E402
 from .grep import Grep  # noqa: E402
 from .patch import PatchFile  # noqa: E402

kimi_cli/tools/file/glob.md

@@ -14,4 +14,4 @@ Find files and directories using glob patterns. This tool supports standard glob
 
 **Bad example patterns:**
 - `**`, `**/*.py` - Any pattern starting with '**' will be rejected. Because it would recursively search all directories and subdirectories, which is very likely to yield large result that exceeds your context size. Always use more specific patterns like `src/**/*.py` instead.
-- `node_modules/**/*.js` - Although this does not start with '**', it would still highly possible to yield large result because `node_modules` is well-known to contain too many directories and files. Avoid recursivelly searching in such directories, other examples include `venv`, `.venv`, `__pycache__`, `target`. If you really need to search in a dependency, use more specific patterns like `node_modules/react/src/*` instead.
+- `node_modules/**/*.js` - Although this does not start with '**', it would still highly possible to yield large result because `node_modules` is well-known to contain too many directories and files. Avoid recursively searching in such directories, other examples include `venv`, `.venv`, `__pycache__`, `target`. If you really need to search in a dependency, use more specific patterns like `node_modules/react/src/*` instead.

kimi_cli/tools/file/glob.py

@@ -2,13 +2,13 @@
 
 import asyncio
 from pathlib import Path
-from typing import override
+from typing import Any, override
 
 import aiofiles.os
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import BuiltinSystemPromptArgs
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
 from kimi_cli.tools.utils import load_desc
 
 MAX_MATCHES = 1000
@@ -38,7 +38,7 @@ class Glob(CallableTool2[Params]):
     )
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
 
@@ -128,7 +128,7 @@ class Glob(CallableTool2[Params]):
             message = (
                 f"Found {len(matches)} matches for pattern `{params.pattern}`."
                 if len(matches) > 0
-                else "No matches found for pattern `{params.pattern}`."
+                else f"No matches found for pattern `{params.pattern}`."
             )
             if len(matches) > MAX_MATCHES:
                 matches = matches[:MAX_MATCHES]

kimi_cli/tools/file/grep.py

@@ -1,20 +1,22 @@
 import asyncio
-import os
 import platform
 import shutil
 import stat
 import tarfile
 import tempfile
+import zipfile
 from pathlib import Path
 from typing import override
 
 import aiohttp
-import ripgrepy
+import ripgrepy  # pyright: ignore[reportMissingTypeStubs]
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
 import kimi_cli
 from kimi_cli.share import get_share_dir
+from kimi_cli.tools.utils import load_desc
+from kimi_cli.utils.aiohttp import new_client_session
 from kimi_cli.utils.logging import logger
 
 
@@ -112,7 +114,7 @@ _RG_DOWNLOAD_LOCK = asyncio.Lock()
 
 
 def _rg_binary_name() -> str:
-    return "rg.exe" if os.name == "nt" else "rg"
+    return "rg.exe" if platform.system() == "Windows" else "rg"
 
 
 def _find_existing_rg(bin_name: str) -> Path | None:
@@ -147,6 +149,8 @@ def _detect_target() -> str | None:
         os_name = "apple-darwin"
     elif sys_name == "Linux":
         os_name = "unknown-linux-musl" if arch == "x86_64" else "unknown-linux-gnu"
+    elif sys_name == "Windows":
+        os_name = "pc-windows-msvc"
     else:
         logger.error("Unsupported operating system for ripgrep: {sys_name}", sys_name=sys_name)
         return None
@@ -159,7 +163,9 @@ async def _download_and_install_rg(bin_name: str) -> Path:
     if not target:
         raise RuntimeError("Unsupported platform for ripgrep download")
 
-    filename = f"ripgrep-{RG_VERSION}-{target}.tar.gz"
+    is_windows = "windows" in target
+    archive_ext = "zip" if is_windows else "tar.gz"
+    filename = f"ripgrep-{RG_VERSION}-{target}.{archive_ext}"
     url = f"{RG_BASE_URL}/{filename}"
     logger.info("Downloading ripgrep from {url}", url=url)
 
@@ -167,7 +173,7 @@ async def _download_and_install_rg(bin_name: str) -> Path:
     share_bin_dir.mkdir(parents=True, exist_ok=True)
     destination = share_bin_dir / bin_name
 
-    async with aiohttp.ClientSession() as session:
+    async with new_client_session() as session:
         with tempfile.TemporaryDirectory(prefix="kimi-rg-") as tmpdir:
             tar_path = Path(tmpdir) / filename
 
@@ -182,19 +188,30 @@ async def _download_and_install_rg(bin_name: str) -> Path:
                 raise RuntimeError("Failed to download ripgrep binary") from exc
 
             try:
-                with tarfile.open(tar_path, "r:gz") as tar:
-                    member = next(
-                        (m for m in tar.getmembers() if Path(m.name).name == bin_name),
-                        None,
-                    )
-                    if not member:
-                        raise RuntimeError("Ripgrep binary not found in archive")
-                    extracted = tar.extractfile(member)
-                    if not extracted:
-                        raise RuntimeError("Failed to extract ripgrep binary")
-                    with open(destination, "wb") as dest_fh:
-                        shutil.copyfileobj(extracted, dest_fh)
-            except (tarfile.TarError, OSError) as exc:
+                if is_windows:
+                    with zipfile.ZipFile(tar_path, "r") as zf:
+                        member_name = next(
+                            (name for name in zf.namelist() if Path(name).name == bin_name),
+                            None,
+                        )
+                        if not member_name:
+                            raise RuntimeError("Ripgrep binary not found in archive")
+                        with zf.open(member_name) as source, open(destination, "wb") as dest_fh:
+                            shutil.copyfileobj(source, dest_fh)
+                else:
+                    with tarfile.open(tar_path, "r:gz") as tar:
+                        member = next(
+                            (m for m in tar.getmembers() if Path(m.name).name == bin_name),
+                            None,
+                        )
+                        if not member:
+                            raise RuntimeError("Ripgrep binary not found in archive")
+                        extracted = tar.extractfile(member)
+                        if not extracted:
+                            raise RuntimeError("Failed to extract ripgrep binary")
+                        with open(destination, "wb") as dest_fh:
+                            shutil.copyfileobj(extracted, dest_fh)
+            except (zipfile.BadZipFile, tarfile.TarError, OSError) as exc:
                 raise RuntimeError("Failed to extract ripgrep archive") from exc
 
     destination.chmod(destination.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
@@ -219,7 +236,7 @@ async def _ensure_rg_path() -> str:
 
 class Grep(CallableTool2[Params]):
     name: str = "Grep"
-    description: str = (Path(__file__).parent / "grep.md").read_text()
+    description: str = load_desc(Path(__file__).parent / "grep.md")
     params: type[Params] = Params
 
     @override

kimi_cli/tools/file/patch.py

@@ -1,12 +1,45 @@
 from pathlib import Path
-from typing import override
+from typing import Any, Literal, override
 
 import aiofiles
-import patch_ng
+import patch_ng  # pyright: ignore[reportMissingTypeStubs]
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
 from pydantic import BaseModel, Field
 
-from kimi_cli.agent import BuiltinSystemPromptArgs
+from kimi_cli.soul.approval import Approval
+from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
+from kimi_cli.tools.file import FileActions
+from kimi_cli.tools.utils import ToolRejectedError, load_desc
+
+
+def _parse_patch(diff_bytes: bytes) -> patch_ng.PatchSet | None:
+    """Parse patch from bytes, returning PatchSet or None on error.
+
+    This wrapper provides type hints for the untyped patch_ng.fromstring function.
+    """
+    result: patch_ng.PatchSet | Literal[False] = patch_ng.fromstring(diff_bytes)  # pyright: ignore[reportUnknownMemberType]
+    return result if result is not False else None
+
+
+def _count_hunks(patch_set: patch_ng.PatchSet) -> int:
+    """Count total hunks across all items in a PatchSet.
+
+    This wrapper provides type hints for the untyped patch_ng library.
+    From source code inspection: PatchSet.items is list[Patch], Patch.hunks is list[Hunk].
+    Type ignore needed because patch_ng lacks type annotations.
+    """
+    items: list[patch_ng.Patch] = patch_set.items  # pyright: ignore[reportUnknownMemberType]
+    # Each Patch has a hunks attribute (list[Hunk])
+    return sum(len(item.hunks) for item in items)  # pyright: ignore[reportUnknownArgumentType, reportUnknownMemberType]
+
+
+def _apply_patch(patch_set: patch_ng.PatchSet, root: str) -> bool:
+    """Apply a patch to files under the given root directory.
+
+    This wrapper provides type hints for the untyped patch_ng.apply method.
+    """
+    success: Any = patch_set.apply(root=root)  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+    return bool(success)  # pyright: ignore[reportUnknownArgumentType]
 
 
 class Params(BaseModel):
@@ -16,12 +49,13 @@ class Params(BaseModel):
 
 class PatchFile(CallableTool2[Params]):
     name: str = "PatchFile"
-    description: str = (Path(__file__).parent / "patch.md").read_text()
+    description: str = load_desc(Path(__file__).parent / "patch.md")
     params: type[Params] = Params
 
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs: Any):
         super().__init__(**kwargs)
         self._work_dir = builtin_args.KIMI_WORK_DIR
+        self._approval = approval
 
     def _validate_path(self, path: Path) -> ToolError | None:
         """Validate that the path is safe to patch."""
@@ -70,15 +104,23 @@ class PatchFile(CallableTool2[Params]):
                     brief="Invalid path",
                 )
 
+            # Request approval
+            if not await self._approval.request(
+                self.name,
+                FileActions.EDIT,
+                f"Patch file `{params.path}`",
+            ):
+                return ToolRejectedError()
+
             # Read the file content
             async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
                 original_content = await f.read()
 
             # Create patch object directly from string (no temporary file needed!)
-            patch_set = patch_ng.fromstring(params.diff.encode("utf-8"))
+            patch_set = _parse_patch(params.diff.encode("utf-8"))
 
-            # Handle case where patch_ng.fromstring returns False on parse errors
-            if not patch_set or patch_set is True:
+            # Handle case where parsing failed
+            if patch_set is None:
                 return ToolError(
                     message=(
                         "Failed to parse diff content: invalid patch format or no valid hunks found"
@@ -87,7 +129,7 @@ class PatchFile(CallableTool2[Params]):
                 )
 
             # Count total hunks across all items
-            total_hunks = sum(len(item.hunks) for item in patch_set.items)
+            total_hunks = _count_hunks(patch_set)
 
             if total_hunks == 0:
                 return ToolError(
@@ -96,7 +138,7 @@ class PatchFile(CallableTool2[Params]):
                 )
 
             # Apply the patch
-            success = patch_set.apply(root=str(p.parent))
+            success = _apply_patch(patch_set, str(p.parent))
 
             if not success:
                 return ToolError(