klaude-code 1.2.12__py3-none-any.whl → 1.2.14__py3-none-any.whl

klaude_code/core/prompt.py

@@ -1,9 +1,11 @@
 import datetime
 import shutil
-from functools import lru_cache
+from functools import cache
 from importlib.resources import files
 from pathlib import Path
 
+from klaude_code.protocol import llm_param
+
 COMMAND_DESCRIPTIONS: dict[str, str] = {
     "rg": "ripgrep - fast text search",
     "fd": "simple and fast alternative to find",
@@ -25,7 +27,7 @@ PROMPT_FILES: dict[str, str] = {
 }
 
 
-@lru_cache(maxsize=None)
+@cache
 def _load_base_prompt(file_key: str) -> str:
     """Load and cache the base prompt content from file."""
     try:
@@ -36,13 +38,13 @@ def _load_base_prompt(file_key: str) -> str:
     return files(__package__).joinpath(prompt_path).read_text(encoding="utf-8").strip()
 
 
-def _get_file_key(model_name: str, sub_agent_type: str | None) -> str:
+def _get_file_key(model_name: str, protocol: llm_param.LLMClientProtocol, sub_agent_type: str | None) -> str:
     """Determine which prompt file to use based on model and agent type."""
     if sub_agent_type is not None:
         return sub_agent_type
 
     match model_name:
-        case "gpt-5.1-codex-max":
+        case name if "gpt-5.1-codex-max" in name:
             return "main_gpt_5_1_codex_max"
         case name if "gpt-5" in name:
             return "main_gpt_5_1"
@@ -84,12 +86,15 @@ def _build_env_info(model_name: str) -> str:
     return "\n".join(env_lines)
 
 
-def load_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
+def load_system_prompt(
+    model_name: str, protocol: llm_param.LLMClientProtocol, sub_agent_type: str | None = None
+) -> str:
     """Get system prompt content for the given model and sub-agent type."""
-    file_key = _get_file_key(model_name, sub_agent_type)
+    file_key = _get_file_key(model_name, protocol, sub_agent_type)
     base_prompt = _load_base_prompt(file_key)
 
-    if model_name == "gpt-5.1-codex-max":
+    if protocol == llm_param.LLMClientProtocol.CODEX:
+        # Do not append environment info for Codex protocol
         return base_prompt
 
     return base_prompt + _build_env_info(model_name)

klaude_code/core/reminders.py

@@ -1,8 +1,8 @@
 import json
 import re
 import shlex
+from collections.abc import Awaitable, Callable
 from pathlib import Path
-from typing import Awaitable, Callable
 
 from pydantic import BaseModel
 

klaude_code/core/task.py

@@ -119,7 +119,7 @@ class TaskExecutionContext:
     profile: AgentProfile
     tool_registry: dict[str, type[ToolABC]]
     # For reminder processing - needs access to session
-    process_reminder: Callable[[Reminder], AsyncGenerator[events.DeveloperMessageEvent, None]]
+    process_reminder: Callable[[Reminder], AsyncGenerator[events.DeveloperMessageEvent]]
     sub_agent_state: model.SubAgentState | None
 
 
@@ -146,7 +146,7 @@ class TaskExecutor:
             self._current_turn = None
         return ui_events
 
-    async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event, None]:
+    async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event]:
         """Execute the task, yielding events as they occur."""
         ctx = self._context
         session_ctx = ctx.session_ctx

klaude_code/core/tool/__init__.py

@@ -29,49 +29,40 @@ from .web.mermaid_tool import MermaidTool
 from .web.web_fetch_tool import WebFetchTool
 
 __all__ = [
-    # Tools
+    "MEMORY_DIR_NAME",
     "ApplyPatchTool",
     "BashTool",
+    "DiffError",
     "EditTool",
     "MemoryTool",
     "MermaidTool",
     "MultiEditTool",
     "ReadTool",
+    "SafetyCheckResult",
+    "SimpleTruncationStrategy",
+    "Skill",
+    "SkillLoader",
     "SkillTool",
     "SubAgentTool",
+    "TodoContext",
     "TodoWriteTool",
+    "ToolABC",
+    "ToolContextToken",
+    "TruncationStrategy",
     "UpdatePlanTool",
     "WebFetchTool",
     "WriteTool",
-    # Tool ABC
-    "ToolABC",
-    # Tool context
-    "TodoContext",
     "build_todo_context",
-    "ToolContextToken",
     "current_run_subtask_callback",
-    "reset_tool_context",
-    "set_tool_context_from_session",
-    "tool_context",
-    # Tool registry
-    "load_agent_tools",
     "get_registry",
     "get_tool_schemas",
-    "run_tool",
-    # Truncation
-    "SimpleTruncationStrategy",
-    "TruncationStrategy",
     "get_truncation_strategy",
-    "set_truncation_strategy",
-    # Command safety
-    "SafetyCheckResult",
     "is_safe_command",
-    # Skill
-    "Skill",
-    "SkillLoader",
-    # Memory
-    "MEMORY_DIR_NAME",
-    # Apply patch
-    "DiffError",
+    "load_agent_tools",
     "process_patch",
+    "reset_tool_context",
+    "run_tool",
+    "set_tool_context_from_session",
+    "set_truncation_strategy",
+    "tool_context",
 ]

klaude_code/core/tool/file/_utils.py

@@ -18,7 +18,7 @@ def file_exists(path: str) -> bool:
 
 def read_text(path: str) -> str:
     """Read text from file with UTF-8 encoding."""
-    with open(path, "r", encoding="utf-8", errors="replace") as f:
+    with open(path, encoding="utf-8", errors="replace") as f:
         return f.read()
 
 

klaude_code/core/tool/file/apply_patch.py

@@ -3,8 +3,8 @@ https://github.com/openai/openai-cookbook/blob/main/examples/gpt-5/apply_patch.p
 """
 
 import os
+from collections.abc import Callable
 from enum import Enum
-from typing import Callable, Optional
 
 from pydantic import BaseModel, Field
 
@@ -17,16 +17,16 @@ class ActionType(str, Enum):
 
 class FileChange(BaseModel):
     type: ActionType
-    old_content: Optional[str] = None
-    new_content: Optional[str] = None
-    move_path: Optional[str] = None
+    old_content: str | None = None
+    new_content: str | None = None
+    move_path: str | None = None
 
 
 class Commit(BaseModel):
     changes: dict[str, FileChange] = Field(default_factory=dict)
 
 
-def assemble_changes(orig: dict[str, Optional[str]], dest: dict[str, Optional[str]]) -> Commit:
+def assemble_changes(orig: dict[str, str | None], dest: dict[str, str | None]) -> Commit:
     commit = Commit()
     for path in sorted(set(orig.keys()).union(dest.keys())):
         old_content = orig.get(path)
@@ -49,7 +49,7 @@ def assemble_changes(orig: dict[str, Optional[str]], dest: dict[str, Optional[st
                     old_content=old_content,
                 )
             else:
-                assert False
+                raise AssertionError()
     return commit
 
 
@@ -71,9 +71,9 @@ def _new_chunk_list() -> list["Chunk"]:
 
 class PatchAction(BaseModel):
     type: ActionType
-    new_file: Optional[str] = None
+    new_file: str | None = None
     chunks: list[Chunk] = Field(default_factory=_new_chunk_list)
-    move_path: Optional[str] = None
+    move_path: str | None = None
 
 
 class Patch(BaseModel):
@@ -87,26 +87,19 @@ class Parser(BaseModel):
     patch: Patch = Field(default_factory=Patch)
     fuzz: int = 0
 
-    def is_done(self, prefixes: Optional[tuple[str, ...]] = None) -> bool:
+    def is_done(self, prefixes: tuple[str, ...] | None = None) -> bool:
         if self.index >= len(self.lines):
             return True
-        if prefixes and self.lines[self.index].startswith(prefixes):
-            return True
-        return False
+        return bool(prefixes and self.lines[self.index].startswith(prefixes))
 
     def startswith(self, prefix: str | tuple[str, ...]) -> bool:
         assert self.index < len(self.lines), f"Index: {self.index} >= {len(self.lines)}"
-        if self.lines[self.index].startswith(prefix):
-            return True
-        return False
+        return self.lines[self.index].startswith(prefix)
 
     def read_str(self, prefix: str = "", return_everything: bool = False) -> str:
         assert self.index < len(self.lines), f"Index: {self.index} >= {len(self.lines)}"
         if self.lines[self.index].startswith(prefix):
-            if return_everything:
-                text = self.lines[self.index]
-            else:
-                text = self.lines[self.index][len(prefix) :]
+            text = self.lines[self.index] if return_everything else self.lines[self.index][len(prefix) :]
             self.index += 1
             return text
         return ""
@@ -167,10 +160,9 @@ class Parser(BaseModel):
         ):
             def_str = self.read_str("@@ ")
             section_str = ""
-            if not def_str:
-                if self.lines[self.index] == "@@":
-                    section_str = self.lines[self.index]
-                    self.index += 1
+            if not def_str and self.lines[self.index] == "@@":
+                section_str = self.lines[self.index]
+                self.index += 1
             if not (def_str or section_str or index == 0):
                 raise DiffError(f"Invalid Line:\n{self.lines[self.index]}")
             if def_str.strip():
@@ -457,7 +449,7 @@ def process_patch(
 
 
 def open_file(path: str) -> str:
-    with open(path, "rt") as f:
+    with open(path) as f:
         return f.read()
 
 
@@ -465,7 +457,7 @@ def write_file(path: str, content: str) -> None:
     if "/" in path:
         parent = "/".join(path.split("/")[:-1])
         os.makedirs(parent, exist_ok=True)
-    with open(path, "wt") as f:
+    with open(path, "w") as f:
         f.write(content)
 
 

klaude_code/core/tool/file/apply_patch_tool.py

@@ -1,6 +1,7 @@
 """ApplyPatch tool providing direct patch application capability."""
 
 import asyncio
+import contextlib
 import difflib
 import os
 from pathlib import Path
@@ -58,7 +59,7 @@ class ApplyPatchHandler:
             if os.path.isdir(resolved):
                 raise ap.DiffError(f"Cannot apply patch to directory: {path}")
             try:
-                with open(resolved, "r", encoding="utf-8") as handle:
+                with open(resolved, encoding="utf-8") as handle:
                     orig[path] = handle.read()
             except OSError as error:
                 raise ap.DiffError(f"Failed to read {path}: {error}") from error
@@ -78,10 +79,8 @@ class ApplyPatchHandler:
                 handle.write(content)
 
             if file_tracker is not None:
-                try:
+                with contextlib.suppress(Exception):  # pragma: no cover - file tracker best-effort
                     file_tracker[resolved] = Path(resolved).stat().st_mtime
-                except Exception:  # pragma: no cover - file tracker best-effort
-                    pass
 
         def remove_fn(path: str) -> None:
             resolved = resolve_path(path)
@@ -92,10 +91,8 @@ class ApplyPatchHandler:
             os.remove(resolved)
 
             if file_tracker is not None:
-                try:
+                with contextlib.suppress(Exception):  # pragma: no cover - file tracker best-effort
                     file_tracker.pop(resolved, None)
-                except Exception:  # pragma: no cover - file tracker best-effort
-                    pass
 
         ap.apply_commit(commit, write_fn, remove_fn)
         return "Done!", diff_text

klaude_code/core/tool/file/edit_tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import difflib
 import os
 from pathlib import Path
@@ -191,10 +192,8 @@ class EditTool(ToolABC):
 
         # Update tracker with new mtime
         if file_tracker is not None:
-            try:
+            with contextlib.suppress(Exception):
                 file_tracker[file_path] = Path(file_path).stat().st_mtime
-            except Exception:
-                pass
 
         # Build output message
         if args.replace_all:
@@ -213,18 +212,12 @@ class EditTool(ToolABC):
                     header = line
                     plus = header.split("+", 1)[1]
                     plus_range = plus.split(" ")[0]
-                    if "," in plus_range:
-                        start = int(plus_range.split(",")[0])
-                    else:
-                        start = int(plus_range)
+                    start = int(plus_range.split(",")[0]) if "," in plus_range else int(plus_range)
                     after_line_no = start - 1
                 except Exception:
                     after_line_no = 0
                 continue
-            if line.startswith(" "):
-                after_line_no += 1
-                include_after_line_nos.append(after_line_no)
-            elif line.startswith("+") and not line.startswith("+++ "):
+            if line.startswith(" ") or (line.startswith("+") and not line.startswith("+++ ")):
                 after_line_no += 1
                 include_after_line_nos.append(after_line_no)
             elif line.startswith("-") and not line.startswith("--- "):

klaude_code/core/tool/file/multi_edit_tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import difflib
 import os
 from pathlib import Path
@@ -162,10 +163,8 @@ class MultiEditTool(ToolABC):
 
         # Update tracker
         if file_tracker is not None:
-            try:
+            with contextlib.suppress(Exception):
                 file_tracker[file_path] = Path(file_path).stat().st_mtime
-            except Exception:
-                pass
 
         # Build output message
         lines = [f"Applied {len(args.edits)} edits to {file_path}:"]

klaude_code/core/tool/file/read_tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import os
 from base64 import b64encode
 from dataclasses import dataclass
@@ -58,7 +59,7 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     remaining_selected_beyond_cap = 0
     selected_lines: list[tuple[int, str]] = []
     selected_chars = 0
-    with open(options.file_path, "r", encoding="utf-8", errors="replace") as f:
+    with open(options.file_path, encoding="utf-8", errors="replace") as f:
         for line_no, raw_line in enumerate(f, start=1):
             total_lines = line_no
             within = line_no >= options.offset and (options.limit is None or selected_lines_count < options.limit)
@@ -90,10 +91,8 @@ def _track_file_access(file_path: str) -> None:
     file_tracker = get_current_file_tracker()
     if file_tracker is None or not file_exists(file_path) or is_directory(file_path):
         return
-    try:
+    with contextlib.suppress(Exception):
         file_tracker[file_path] = Path(file_path).stat().st_mtime
-    except Exception:
-        pass
 
 
 def _is_supported_image_file(file_path: str) -> bool:

klaude_code/core/tool/file/write_tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import difflib
 import os
 from pathlib import Path
@@ -98,10 +99,8 @@ class WriteTool(ToolABC):
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
         if file_tracker is not None:
-            try:
+            with contextlib.suppress(Exception):
                 file_tracker[file_path] = Path(file_path).stat().st_mtime
-            except Exception:
-                pass
 
         # Build diff between previous and new content
         after = args.content

klaude_code/core/tool/memory/memory_tool.py

@@ -68,16 +68,10 @@ def _validate_path(virtual_path: str) -> tuple[Path | None, str | None]:
         return None, f"Path must start with {MEMORY_VIRTUAL_ROOT}"
 
     # Get relative path from /memories
-    if virtual_path == MEMORY_VIRTUAL_ROOT:
-        relative = ""
-    else:
-        relative = virtual_path[len(MEMORY_VIRTUAL_ROOT) :].lstrip("/")
+    relative = "" if virtual_path == MEMORY_VIRTUAL_ROOT else virtual_path[len(MEMORY_VIRTUAL_ROOT) :].lstrip("/")
 
     memories_root = _get_memories_root()
-    if relative:
-        actual_path = memories_root / relative
-    else:
-        actual_path = memories_root
+    actual_path = memories_root / relative if relative else memories_root
 
     # Resolve to canonical path and verify it's still within memories
     try:

klaude_code/core/tool/memory/skill_loader.py

@@ -1,6 +1,7 @@
 import re
 from dataclasses import dataclass
 from pathlib import Path
+from typing import ClassVar
 
 import yaml
 
@@ -36,13 +37,13 @@ class SkillLoader:
     """Load and manage Claude Skills from SKILL.md files"""
 
     # User-level skills directories (checked in order, later ones override earlier ones with same name)
-    USER_SKILLS_DIRS = [
+    USER_SKILLS_DIRS: ClassVar[list[Path]] = [
         Path("~/.claude/skills"),
         Path("~/.klaude/skills"),
         # Path("~/.claude/plugins/marketplaces"),
     ]
     # Project-level skills directory
-    PROJECT_SKILLS_DIR = Path("./.claude/skills")
+    PROJECT_SKILLS_DIR: ClassVar[Path] = Path("./.claude/skills")
 
     def __init__(self) -> None:
         """Initialize the skill loader"""

klaude_code/core/tool/shell/command_safety.py

@@ -293,7 +293,6 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
         "ruff",
         "pyright",
         "make",
-        "isort",
         "npm",
         "pnpm",
         "bun",

klaude_code/core/tool/tool_context.py

@@ -83,9 +83,7 @@ def reset_tool_context(token: ToolContextToken) -> None:
 
 
 @contextmanager
-def tool_context(
-    file_tracker: MutableMapping[str, float], todo_ctx: TodoContext
-) -> Generator[ToolContextToken, None, None]:
+def tool_context(file_tracker: MutableMapping[str, float], todo_ctx: TodoContext) -> Generator[ToolContextToken]:
     """Context manager for setting and resetting tool execution context."""
 
     file_tracker_token = current_file_tracker_var.set(file_tracker)

klaude_code/core/tool/tool_registry.py

@@ -1,4 +1,5 @@
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from klaude_code.core.tool.sub_agent_tool import SubAgentTool
 from klaude_code.core.tool.tool_abc import ToolABC

klaude_code/core/tool/tool_runner.py

@@ -100,7 +100,7 @@ class ToolExecutor:
         self._call_event_emitted: set[str] = set()
         self._sub_agent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
 
-    async def run_tools(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[ToolExecutorEvent, None]:
+    async def run_tools(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[ToolExecutorEvent]:
         """Run the given tool calls and yield execution events.
 
         Tool calls are partitioned into regular tools and sub-agent tools. Regular tools

klaude_code/core/tool/truncation.py

@@ -27,10 +27,7 @@ def _extract_url_filename(url: str) -> str:
     # Combine host and path for a meaningful filename
     host = parsed.netloc.replace(".", "_").replace(":", "_")
     path = parsed.path.strip("/").replace("/", "_")
-    if path:
-        name = f"{host}_{path}"
-    else:
-        name = host
+    name = f"{host}_{path}" if path else host
     # Sanitize: keep only alphanumeric, underscore, hyphen
     name = re.sub(r"[^a-zA-Z0-9_\-]", "_", name)
     # Limit length
@@ -106,7 +103,7 @@ class SmartTruncationStrategy(TruncationStrategy):
             file_path = self.truncation_dir / filename
             file_path.write_text(output, encoding="utf-8")
             return str(file_path)
-        except (OSError, IOError):
+        except OSError:
             return None
 
     def truncate(self, output: str, tool_call: model.ToolCallItem | None = None) -> TruncationResult:

klaude_code/core/turn.py

@@ -114,7 +114,7 @@ class TurnExecutor:
             self._tool_executor = None
         return ui_events
 
-    async def run(self) -> AsyncGenerator[events.Event, None]:
+    async def run(self) -> AsyncGenerator[events.Event]:
         """Execute the turn, yielding events as they occur.
 
         Raises:
@@ -148,7 +148,7 @@ class TurnExecutor:
 
         yield events.TurnEndEvent(session_id=session_ctx.session_id)
 
-    async def _consume_llm_stream(self, turn_result: TurnResult) -> AsyncGenerator[events.Event, None]:
+    async def _consume_llm_stream(self, turn_result: TurnResult) -> AsyncGenerator[events.Event]:
         """Stream events from LLM and update turn_result in place."""
 
         ctx = self._context
@@ -179,6 +179,12 @@ class TurnExecutor:
                     )
                 case model.ReasoningEncryptedItem() as item:
                     turn_result.reasoning_items.append(item)
+                case model.ReasoningTextDelta() as item:
+                    yield events.ThinkingDeltaEvent(
+                        content=item.content,
+                        response_id=item.response_id,
+                        session_id=session_ctx.session_id,
+                    )
                 case model.AssistantMessageDelta() as item:
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
@@ -228,7 +234,7 @@ class TurnExecutor:
         if turn_result.tool_calls:
             session_ctx.append_history(turn_result.tool_calls)
 
-    async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event, None]:
+    async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event]:
         """Run tools for the turn and translate executor events to UI events."""
 
         ctx = self._context

klaude_code/llm/anthropic/client.py

@@ -74,7 +74,7 @@ class AnthropicClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -122,6 +122,10 @@ class AnthropicClient(LLMClientABC):
                             case BetaThinkingDelta() as delta:
                                 metadata_tracker.record_token()
                                 accumulated_thinking.append(delta.thinking)
+                                yield model.ReasoningTextDelta(
+                                    content=delta.thinking,
+                                    response_id=response_id,
+                                )
                             case BetaSignatureDelta() as delta:
                                 metadata_tracker.record_token()
                                 yield model.ReasoningEncryptedItem(
@@ -197,4 +201,4 @@ class AnthropicClient(LLMClientABC):
                     case _:
                         pass
         except (APIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")

klaude_code/llm/client.py

@@ -15,7 +15,7 @@ class LLMClientABC(ABC):
         pass
 
     @abstractmethod
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         raise NotImplementedError
         yield cast(model.ConversationItem, None)
 
@@ -26,6 +26,10 @@ class LLMClientABC(ABC):
     def model_name(self) -> str:
         return self._config.model or ""
 
+    @property
+    def protocol(self) -> llm_param.LLMClientProtocol:
+        return self._config.protocol
+
 
 P = ParamSpec("P")
 R = TypeVar("R")

klaude_code/llm/codex/client.py

@@ -114,7 +114,7 @@ class CodexClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         # Ensure token is valid before API call
         self._ensure_valid_token()
 
@@ -142,7 +142,7 @@ class CodexClient(LLMClientABC):
                 extra_headers=extra_headers,
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):

klaude_code/llm/input_common.py

@@ -5,10 +5,10 @@ This module provides shared abstractions for providers that require message grou
 since it uses a flat item list matching our internal protocol.
 """
 
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from klaude_code import const