klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/core/tool/file/multi_edit_tool.py

@@ -11,9 +11,7 @@ from klaude_code.core.tool.file.edit_tool import EditTool
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import ToolResultItem, ToolResultUIExtra, ToolResultUIExtraType
-from klaude_code.protocol.tools import MULTI_EDIT
+from klaude_code.protocol import llm_param, model, tools
 
 
 def _is_directory(path: str) -> bool:
@@ -42,7 +40,7 @@ def _write_text(path: str, content: str) -> None:
         f.write(content)
 
 
-@register(MULTI_EDIT)
+@register(tools.MULTI_EDIT)
 class MultiEditTool(ToolABC):
     class MultiEditEditItem(BaseModel):
         old_string: str
@@ -54,9 +52,9 @@ class MultiEditTool(ToolABC):
         edits: list[MultiEditTool.MultiEditEditItem]
 
     @classmethod
-    def schema(cls) -> ToolSchema:
-        return ToolSchema(
-            name=MULTI_EDIT,
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.MULTI_EDIT,
             type="function",
             description=load_desc(Path(__file__).parent / "multi_edit_tool.md"),
             parameters={
@@ -98,17 +96,17 @@ class MultiEditTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> ToolResultItem:
+    async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = MultiEditTool.MultiEditArguments.model_validate_json(arguments)
         except Exception as e:  # pragma: no cover - defensive
-            return ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
 
         file_path = os.path.abspath(args.file_path)
 
         # Directory error first
         if _is_directory(file_path):
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. multi_edit</tool_use_error>",
             )
@@ -120,7 +118,7 @@ class MultiEditTool(ToolABC):
             if file_tracker is not None:
                 tracked = file_tracker.get(file_path)
                 if tracked is None:
-                    return ToolResultItem(
+                    return model.ToolResultItem(
                         status="error",
                         output=("File has not been read yet. Read it first before writing to it."),
                     )
@@ -129,7 +127,7 @@ class MultiEditTool(ToolABC):
                 except Exception:
                     current_mtime = tracked
                 if current_mtime != tracked:
-                    return ToolResultItem(
+                    return model.ToolResultItem(
                         status="error",
                         output=(
                             "File has been modified externally. Either by user or a linter. Read it first before writing to it."
@@ -138,7 +136,7 @@ class MultiEditTool(ToolABC):
         else:
             # Allow creation only if first edit is creating content (old_string == "")
             if not args.edits or args.edits[0].old_string != "":
-                return ToolResultItem(
+                return model.ToolResultItem(
                     status="error",
                     output=("File has not been read yet. Read it first before writing to it."),
                 )
@@ -159,7 +157,7 @@ class MultiEditTool(ToolABC):
                 replace_all=edit.replace_all,
             )
             if err is not None:
-                return ToolResultItem(status="error", output=err)
+                return model.ToolResultItem(status="error", output=err)
             # Apply to staged content
             staged = EditTool.execute(
                 content=staged,
@@ -172,7 +170,7 @@ class MultiEditTool(ToolABC):
         try:
             await asyncio.to_thread(_write_text, file_path, staged)
         except Exception as e:  # pragma: no cover
-            return ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
+            return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
         # Prepare UI extra: unified diff
         diff_lines = list(
@@ -185,7 +183,7 @@ class MultiEditTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = ToolResultUIExtra(type=ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
 
         # Update tracker
         if file_tracker is not None:
@@ -198,4 +196,4 @@ class MultiEditTool(ToolABC):
         lines = [f"Applied {len(args.edits)} edits to {file_path}:"]
         for i, edit in enumerate(args.edits, start=1):
             lines.append(f'{i}. Replaced "{edit.old_string}" with "{edit.new_string}"')
-        return ToolResultItem(status="success", output="\n".join(lines), ui_extra=ui_extra)
+        return model.ToolResultItem(status="success", output="\n".join(lines), ui_extra=ui_extra)

klaude_code/core/tool/file/read_tool.py

@@ -8,19 +8,11 @@ from pathlib import Path
 
 from pydantic import BaseModel, Field
 
-from klaude_code.const import (
-    READ_CHAR_LIMIT_PER_LINE,
-    READ_GLOBAL_LINE_CAP,
-    READ_MAX_CHARS,
-    READ_MAX_IMAGE_BYTES,
-    READ_MAX_KB,
-)
+from klaude_code import const
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import ImageURLPart, ToolResultItem
-from klaude_code.protocol.tools import READ
+from klaude_code.protocol import llm_param, model, tools
 
 SYSTEM_REMINDER_MALICIOUS = (
     "<system-reminder>\n"
@@ -61,8 +53,8 @@ class ReadOptions:
     file_path: str
     offset: int
     limit: int | None
-    char_limit_per_line: int | None = READ_CHAR_LIMIT_PER_LINE
-    global_line_cap: int | None = READ_GLOBAL_LINE_CAP
+    char_limit_per_line: int | None = const.READ_CHAR_LIMIT_PER_LINE
+    global_line_cap: int | None = const.READ_GLOBAL_LINE_CAP
 
 
 @dataclass
@@ -135,7 +127,7 @@ def _encode_image_to_data_url(file_path: str, mime_type: str) -> str:
     return f"data:{mime_type};base64,{encoded}"
 
 
-@register(READ)
+@register(tools.READ)
 class ReadTool(ToolABC):
     class ReadArguments(BaseModel):
         file_path: str
@@ -143,9 +135,9 @@ class ReadTool(ToolABC):
         limit: int | None = Field(default=None)
 
     @classmethod
-    def schema(cls) -> ToolSchema:
-        return ToolSchema(
-            name=READ,
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.READ,
             type="function",
             description=load_desc(Path(__file__).parent / "read_tool.md"),
             parameters={
@@ -170,20 +162,25 @@ class ReadTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> ToolResultItem:
+    async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = ReadTool.ReadArguments.model_validate_json(arguments)
         except Exception as e:  # pragma: no cover - defensive
-            return ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
         return await cls.call_with_args(args)
 
     @classmethod
     def _effective_limits(cls) -> tuple[int | None, int | None, int | None, int | None]:
         """Return effective limits based on current policy: char_per_line, global_line_cap, max_chars, max_kb"""
-        return READ_CHAR_LIMIT_PER_LINE, READ_GLOBAL_LINE_CAP, READ_MAX_CHARS, READ_MAX_KB
+        return (
+            const.READ_CHAR_LIMIT_PER_LINE,
+            const.READ_GLOBAL_LINE_CAP,
+            const.READ_MAX_CHARS,
+            const.READ_MAX_KB,
+        )
 
     @classmethod
-    async def call_with_args(cls, args: ReadTool.ReadArguments) -> ToolResultItem:
+    async def call_with_args(cls, args: ReadTool.ReadArguments) -> model.ToolResultItem:
         # Accept relative path by resolving to absolute (schema encourages absolute)
         file_path = os.path.abspath(args.file_path)
 
@@ -192,15 +189,19 @@ class ReadTool(ToolABC):
 
         # Common file errors
         if _is_directory(file_path):
-            return ToolResultItem(
-                status="error", output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>"
+            return model.ToolResultItem(
+                status="error",
+                output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
         if not _file_exists(file_path):
-            return ToolResultItem(status="error", output="<tool_use_error>File does not exist.</tool_use_error>")
+            return model.ToolResultItem(
+                status="error",
+                output="<tool_use_error>File does not exist.</tool_use_error>",
+            )
 
         # Check for PDF files
         if Path(file_path).suffix.lower() == ".pdf":
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=(
                     "<tool_use_error>PDF files are not supported by this tool. "
@@ -226,9 +227,9 @@ class ReadTool(ToolABC):
 
         is_image_file = _is_supported_image_file(file_path)
         if is_image_file:
-            if size_bytes > READ_MAX_IMAGE_BYTES:
+            if size_bytes > const.READ_MAX_IMAGE_BYTES:
                 size_mb = size_bytes / (1024 * 1024)
-                return ToolResultItem(
+                return model.ToolResultItem(
                     status="error",
                     output=(
                         f"<tool_use_error>Image size ({size_mb:.2f}MB) exceeds maximum supported size (4.00MB) for inline transfer.</tool_use_error>"
@@ -238,7 +239,7 @@ class ReadTool(ToolABC):
                 mime_type = _image_mime_type(file_path)
                 data_url = _encode_image_to_data_url(file_path, mime_type)
             except Exception as exc:
-                return ToolResultItem(
+                return model.ToolResultItem(
                     status="error",
                     output=f"<tool_use_error>Failed to read image file: {exc}</tool_use_error>",
                 )
@@ -246,8 +247,8 @@ class ReadTool(ToolABC):
             _track_file_access(file_path)
             size_kb = size_bytes / 1024.0 if size_bytes else 0.0
             output_text = f"[image] {Path(file_path).name} ({size_kb:.1f}KB)"
-            image_part = ImageURLPart(image_url=ImageURLPart.ImageURL(url=data_url, id=None))
-            return ToolResultItem(status="success", output=output_text, images=[image_part])
+            image_part = model.ImageURLPart(image_url=model.ImageURLPart.ImageURL(url=data_url, id=None))
+            return model.ToolResultItem(status="success", output=output_text, images=[image_part])
 
         if (
             not is_image_file
@@ -257,7 +258,7 @@ class ReadTool(ToolABC):
             and size_bytes > max_kb * 1024
         ):
             size_kb = size_bytes / 1024.0
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=(
                     f"File content ({size_kb:.1f}KB) exceeds maximum allowed size ({max_kb}KB). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
@@ -285,10 +286,14 @@ class ReadTool(ToolABC):
             )
 
         except FileNotFoundError:
-            return ToolResultItem(status="error", output="<tool_use_error>File does not exist.</tool_use_error>")
+            return model.ToolResultItem(
+                status="error",
+                output="<tool_use_error>File does not exist.</tool_use_error>",
+            )
         except IsADirectoryError:
-            return ToolResultItem(
-                status="error", output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>"
+            return model.ToolResultItem(
+                status="error",
+                output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
 
         # If offset beyond total lines, emit system reminder warning
@@ -296,11 +301,11 @@ class ReadTool(ToolABC):
             warn = f"<system-reminder>Warning: the file exists but is shorter than the provided offset ({offset}). The file has {read_result.total_lines} lines.</system-reminder>"
             # Update FileTracker (we still consider it as a read attempt)
             _track_file_access(file_path)
-            return ToolResultItem(status="success", output=warn)
+            return model.ToolResultItem(status="success", output=warn)
 
         # After limit/offset, if total selected chars exceed limit, error (only check if limits are enabled)
         if max_chars is not None and read_result.selected_chars_count > max_chars:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=(
                     f"File content ({read_result.selected_chars_count} chars) exceeds maximum allowed tokens ({max_chars}). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
@@ -318,4 +323,4 @@ class ReadTool(ToolABC):
         # Update FileTracker with last modified time
         _track_file_access(file_path)
 
-        return ToolResultItem(status="success", output=read_result_str)
+        return model.ToolResultItem(status="success", output=read_result_str)

klaude_code/core/tool/file/write_tool.py

@@ -10,9 +10,7 @@ from pydantic import BaseModel
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import ToolResultItem, ToolResultUIExtra, ToolResultUIExtraType
-from klaude_code.protocol.tools import WRITE
+from klaude_code.protocol import llm_param, model, tools
 
 
 def _is_directory(path: str) -> bool:
@@ -46,12 +44,12 @@ class WriteArguments(BaseModel):
     content: str
 
 
-@register(WRITE)
+@register(tools.WRITE)
 class WriteTool(ToolABC):
     @classmethod
-    def schema(cls) -> ToolSchema:
-        return ToolSchema(
-            name=WRITE,
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.WRITE,
             type="function",
             description=load_desc(Path(__file__).parent / "write_tool.md"),
             parameters={
@@ -72,16 +70,16 @@ class WriteTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> ToolResultItem:
+    async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = WriteArguments.model_validate_json(arguments)
         except Exception as e:  # pragma: no cover - defensive
-            return ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
 
         file_path = os.path.abspath(args.file_path)
 
         if _is_directory(file_path):
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
             )
@@ -94,7 +92,7 @@ class WriteTool(ToolABC):
             if file_tracker is not None:
                 tracked_mtime = file_tracker.get(file_path)
             if tracked_mtime is None:
-                return ToolResultItem(
+                return model.ToolResultItem(
                     status="error",
                     output=("File has not been read yet. Read it first before writing to it."),
                 )
@@ -103,7 +101,7 @@ class WriteTool(ToolABC):
             except Exception:
                 current_mtime = tracked_mtime
             if current_mtime != tracked_mtime:
-                return ToolResultItem(
+                return model.ToolResultItem(
                     status="error",
                     output=(
                         "File has been modified externally. Either by user or a linter. "
@@ -122,7 +120,7 @@ class WriteTool(ToolABC):
         try:
             await asyncio.to_thread(_write_text, file_path, args.content)
         except Exception as e:  # pragma: no cover
-            return ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
+            return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
         if file_tracker is not None:
             try:
@@ -142,7 +140,7 @@ class WriteTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = ToolResultUIExtra(type=ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
 
         message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
-        return ToolResultItem(status="success", output=message, ui_extra=ui_extra)
+        return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)