klaude-code 1.2.11__py3-none-any.whl → 1.2.13__py3-none-any.whl

klaude_code/core/manager/llm_clients_builder.py

@@ -7,6 +7,7 @@ from klaude_code.core.manager.llm_clients import LLMClients
 from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
+from klaude_code.protocol.tools import SubAgentType
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -18,10 +19,7 @@ def build_llm_clients(
     """Create an ``LLMClients`` bundle driven by application config."""
 
     # Resolve main agent LLM config
-    if model_override:
-        llm_config = config.get_model_config(model_override)
-    else:
-        llm_config = config.get_main_model_config()
+    llm_config = config.get_model_config(model_override) if model_override else config.get_main_model_config()
 
     log_debug(
         "Main LLM config",
@@ -30,29 +28,18 @@ def build_llm_clients(
         debug_type=DebugType.LLM_CONFIG,
     )
 
-    main_model_name = str(llm_config.model)
-
-    def _main_factory() -> LLMClientABC:
-        return create_llm_client(llm_config)
-
-    clients = LLMClients(
-        main_factory=_main_factory,
-        main_model_name=main_model_name,
-        main_llm_config=llm_config,
-    )
+    main_client = create_llm_client(llm_config)
+    sub_clients: dict[SubAgentType, LLMClientABC] = {}
 
     for profile in iter_sub_agent_profiles():
         model_name = config.subagent_models.get(profile.name)
         if not model_name:
             continue
 
-        if not profile.enabled_for_model(main_model_name):
+        if not profile.enabled_for_model(main_client.model_name):
             continue
 
-        def _factory(model_name_for_factory: str = model_name) -> LLMClientABC:
-            sub_llm_config = config.get_model_config(model_name_for_factory)
-            return create_llm_client(sub_llm_config)
-
-        clients.register_sub_client_factory(profile.name, _factory)
+        sub_llm_config = config.get_model_config(model_name)
+        sub_clients[profile.name] = create_llm_client(sub_llm_config)
 
-    return clients
+    return LLMClients(main=main_client, sub_clients=sub_clients)

klaude_code/core/manager/sub_agent_manager.py

@@ -43,7 +43,7 @@ class SubAgentManager:
         child_session = Session(work_dir=parent_session.work_dir)
         child_session.sub_agent_state = state
 
-        child_profile = self._model_profile_provider.build_profile_eager(
+        child_profile = self._model_profile_provider.build_profile(
             self._llm_clients.get_client(state.sub_agent_type),
             state.sub_agent_type,
         )
@@ -79,12 +79,12 @@ class SubAgentManager:
             raise
         except Exception as exc:  # pragma: no cover - defensive logging
             log_debug(
-                f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                f"Subagent task failed: [{exc.__class__.__name__}] {exc!s}",
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
             return SubAgentResult(
-                task_result=f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                task_result=f"Subagent task failed: [{exc.__class__.__name__}] {exc!s}",
                 session_id="",
                 error=True,
             )

klaude_code/core/prompt.py

@@ -1,6 +1,6 @@
 import datetime
 import shutil
-from functools import lru_cache
+from functools import cache
 from importlib.resources import files
 from pathlib import Path
 
@@ -25,7 +25,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:
@@ -84,7 +84,7 @@ def _build_env_info(model_name: str) -> str:
     return "\n".join(env_lines)
 
 
-def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
+def load_system_prompt(model_name: str, 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)
     base_prompt = _load_base_prompt(file_key)

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

@@ -45,11 +45,10 @@ class MetadataAccumulator:
             acc_usage.cached_tokens += usage.cached_tokens
             acc_usage.reasoning_tokens += usage.reasoning_tokens
             acc_usage.output_tokens += usage.output_tokens
-            acc_usage.last_turn_output_token = usage.output_tokens
             acc_usage.currency = usage.currency
 
-            if usage.context_token is not None:
-                acc_usage.context_token = usage.context_token
+            if usage.context_size is not None:
+                acc_usage.context_size = usage.context_size
             if usage.context_limit is not None:
                 acc_usage.context_limit = usage.context_limit
 
@@ -120,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
 
 
@@ -147,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
@@ -158,7 +158,6 @@ class TurnExecutor:
                 input=session_ctx.get_conversation_history(),
                 system=ctx.system_prompt,
                 tools=ctx.tools,
-                store=False,
                 session_id=session_ctx.session_id,
             )
         ):
@@ -180,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,
@@ -229,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