klaude-code 1.2.9__py3-none-any.whl → 1.2.10__py3-none-any.whl

klaude_code/core/agent.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, Iterable
+from collections.abc import AsyncGenerator, Callable, Iterable
 from dataclasses import dataclass
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
 from klaude_code.core.prompt import get_system_prompt as load_system_prompt
 from klaude_code.core.reminders import Reminder, load_agent_reminders
@@ -14,21 +14,38 @@ from klaude_code.protocol.model import UserInputPayload
 from klaude_code.session import Session
 from klaude_code.trace import DebugType, log_debug
 
+if TYPE_CHECKING:
+    from klaude_code.core.manager.llm_clients import LLMClients
+
 
 @dataclass(frozen=True)
 class AgentProfile:
     """Encapsulates the active LLM client plus prompts/tools/reminders."""
 
-    llm_client: LLMClientABC
+    llm_client_factory: Callable[[], LLMClientABC]
     system_prompt: str | None
     tools: list[llm_param.ToolSchema]
     reminders: list[Reminder]
 
+    _llm_client: LLMClientABC | None = None
+
+    @property
+    def llm_client(self) -> LLMClientABC:
+        if self._llm_client is None:
+            object.__setattr__(self, "_llm_client", self.llm_client_factory())
+        return self._llm_client  # type: ignore[return-value]
+
 
 class ModelProfileProvider(Protocol):
     """Strategy interface for constructing agent profiles."""
 
     def build_profile(
+        self,
+        llm_clients: LLMClients,
+        sub_agent_type: tools.SubAgentType | None = None,
+    ) -> AgentProfile: ...
+
+    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
@@ -39,13 +56,26 @@ class DefaultModelProfileProvider(ModelProfileProvider):
     """Default provider backed by global prompts/tool/reminder registries."""
 
     def build_profile(
+        self,
+        llm_clients: LLMClients,
+        sub_agent_type: tools.SubAgentType | None = None,
+    ) -> AgentProfile:
+        model_name = llm_clients.main_model_name
+        return AgentProfile(
+            llm_client_factory=lambda: llm_clients.main,
+            system_prompt=load_system_prompt(model_name, sub_agent_type),
+            tools=load_agent_tools(model_name, sub_agent_type),
+            reminders=load_agent_reminders(model_name, sub_agent_type),
+        )
+
+    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
         return AgentProfile(
-            llm_client=llm_client,
+            llm_client_factory=lambda: llm_client,
             system_prompt=load_system_prompt(model_name, sub_agent_type),
             tools=load_agent_tools(model_name, sub_agent_type),
             reminders=load_agent_reminders(model_name, sub_agent_type),
@@ -56,13 +86,26 @@ class VanillaModelProfileProvider(ModelProfileProvider):
     """Provider that strips prompts, reminders, and tools for vanilla mode."""
 
     def build_profile(
+        self,
+        llm_clients: LLMClients,
+        sub_agent_type: tools.SubAgentType | None = None,
+    ) -> AgentProfile:
+        model_name = llm_clients.main_model_name
+        return AgentProfile(
+            llm_client_factory=lambda: llm_clients.main,
+            system_prompt=None,
+            tools=load_agent_tools(model_name, vanilla=True),
+            reminders=load_agent_reminders(model_name, vanilla=True),
+        )
+
+    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
         return AgentProfile(
-            llm_client=llm_client,
+            llm_client_factory=lambda: llm_client,
             system_prompt=None,
             tools=load_agent_tools(model_name, vanilla=True),
             reminders=load_agent_reminders(model_name, vanilla=True),
@@ -74,12 +117,13 @@ class Agent:
         self,
         session: Session,
         profile: AgentProfile,
+        model_name: str | None = None,
     ):
         self.session: Session = session
         self.profile: AgentProfile = profile
         self._current_task: TaskExecutor | None = None
-        if not self.session.model_name:
-            self.session.model_name = profile.llm_client.model_name
+        if not self.session.model_name and model_name:
+            self.session.model_name = model_name
 
     def cancel(self) -> Iterable[events.Event]:
         """Handle agent cancellation and persist an interrupt marker and tool cancellations.
@@ -148,11 +192,13 @@ class Agent:
             self.session.append_history([item])
             yield events.DeveloperMessageEvent(session_id=self.session.id, item=item)
 
-    def set_model_profile(self, profile: AgentProfile) -> None:
+    def set_model_profile(self, profile: AgentProfile, model_name: str | None = None) -> None:
         """Apply a fully constructed profile to the agent."""
 
         self.profile = profile
-        if not self.session.model_name:
+        if model_name:
+            self.session.model_name = model_name
+        elif not self.session.model_name:
             self.session.model_name = profile.llm_client.model_name
 
     def get_llm_client(self) -> LLMClientABC:

klaude_code/core/executor.py

@@ -117,7 +117,7 @@ class ExecutorContext:
         if operation.session_id is None:
             raise ValueError("session_id cannot be None")
 
-        await self.agent_manager.ensure_agent(operation.session_id)
+        await self.agent_manager.ensure_agent(operation.session_id, is_new_session=operation.is_new_session)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
         """Handle a user input operation by running it through an agent."""
@@ -482,4 +482,4 @@ class Executor:
 
 # Static type check: ExecutorContext must satisfy OperationHandler protocol.
 # If this line causes a type error, ExecutorContext is missing required methods.
-_: type[OperationHandler] = ExecutorContext  # pyright: ignore[reportUnusedVariable]
+_: type[OperationHandler] = ExecutorContext

klaude_code/core/manager/agent_manager.py

@@ -38,16 +38,15 @@ class AgentManager:
 
         await self._event_queue.put(event)
 
-    async def ensure_agent(self, session_id: str) -> Agent:
+    async def ensure_agent(self, session_id: str, *, is_new_session: bool = False) -> Agent:
         """Return an existing agent for the session or create a new one."""
-
         agent = self._active_agents.get(session_id)
         if agent is not None:
             return agent
 
-        session = Session.load(session_id)
-        profile = self._model_profile_provider.build_profile(self._llm_clients.main)
-        agent = Agent(session=session, profile=profile)
+        session = Session.load(session_id, skip_if_missing=is_new_session)
+        profile = self._model_profile_provider.build_profile(self._llm_clients)
+        agent = Agent(session=session, profile=profile, model_name=self._llm_clients.main_model_name)
 
         async for evt in agent.replay_history():
             await self.emit_event(evt)
@@ -55,7 +54,7 @@ class AgentManager:
         await self.emit_event(
             events.WelcomeEvent(
                 work_dir=str(session.work_dir),
-                llm_config=self._llm_clients.main.get_llm_config(),
+                llm_config=self._llm_clients.get_llm_config(),
             )
         )
 
@@ -76,7 +75,7 @@ class AgentManager:
 
         llm_config = config.get_model_config(model_name)
         llm_client = create_llm_client(llm_config)
-        agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
+        agent.set_model_profile(self._model_profile_provider.build_profile_eager(llm_client), model_name=model_name)
 
         developer_item = model.DeveloperMessageItem(
             content=f"switched to model: {model_name}",

klaude_code/core/manager/llm_clients.py

@@ -2,41 +2,66 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from dataclasses import field as dataclass_field
+from collections.abc import Callable
 
 from klaude_code.llm.client import LLMClientABC
+from klaude_code.protocol import llm_param
 from klaude_code.protocol.tools import SubAgentType
 
 
-def _default_sub_clients() -> dict[SubAgentType, LLMClientABC]:
-    """Return an empty mapping for sub-agent clients.
+class LLMClients:
+    """Container for LLM clients used by main agent and sub-agents."""
 
-    Defined separately so static type checkers can infer the dictionary
-    key and value types instead of treating them as ``Unknown``.
-    """
+    def __init__(
+        self,
+        main_factory: Callable[[], LLMClientABC],
+        main_model_name: str,
+        main_llm_config: llm_param.LLMConfigParameter,
+    ) -> None:
+        self._main_factory: Callable[[], LLMClientABC] | None = main_factory
+        self._main_client: LLMClientABC | None = None
+        self._main_model_name: str = main_model_name
+        self._main_llm_config: llm_param.LLMConfigParameter = main_llm_config
+        self._sub_clients: dict[SubAgentType, LLMClientABC] = {}
+        self._sub_factories: dict[SubAgentType, Callable[[], LLMClientABC]] = {}
 
-    return {}
+    @property
+    def main_model_name(self) -> str:
+        return self._main_model_name
 
+    def get_llm_config(self) -> llm_param.LLMConfigParameter:
+        return self._main_llm_config
 
-@dataclass
-class LLMClients:
-    """Container for LLM clients used by main agent and sub-agents."""
+    @property
+    def main(self) -> LLMClientABC:
+        if self._main_client is None:
+            if self._main_factory is None:
+                raise RuntimeError("Main client factory not set")
+            self._main_client = self._main_factory()
+            self._main_factory = None
+        return self._main_client
 
-    main: LLMClientABC
-    sub_clients: dict[SubAgentType, LLMClientABC] = dataclass_field(default_factory=_default_sub_clients)
+    def register_sub_client_factory(
+        self,
+        sub_agent_type: SubAgentType,
+        factory: Callable[[], LLMClientABC],
+    ) -> None:
+        self._sub_factories[sub_agent_type] = factory
 
     def get_client(self, sub_agent_type: SubAgentType | None = None) -> LLMClientABC:
-        """Return client for a sub-agent type or the main client.
+        """Return client for a sub-agent type or the main client."""
 
-        Args:
-            sub_agent_type: Optional sub-agent type whose client should be returned.
+        if sub_agent_type is None:
+            return self.main
 
-        Returns:
-            The LLM client corresponding to the sub-agent type, or the main client
-            when no specialized client is available.
-        """
+        existing = self._sub_clients.get(sub_agent_type)
+        if existing is not None:
+            return existing
 
-        if sub_agent_type is None:
+        factory = self._sub_factories.get(sub_agent_type)
+        if factory is None:
             return self.main
-        return self.sub_clients.get(sub_agent_type) or self.main
+
+        client = factory()
+        self._sub_clients[sub_agent_type] = client
+        return client

klaude_code/core/manager/llm_clients_builder.py

@@ -32,18 +32,30 @@ def build_llm_clients(
         debug_type=DebugType.LLM_CONFIG,
     )
 
-    main_client = create_llm_client(llm_config)
-    sub_clients: dict[SubAgentType, LLMClientABC] = {}
+    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,
+    )
 
-    # Initialize sub-agent clients
     for sub_agent_type in enabled_sub_agents or []:
         model_name = config.subagent_models.get(sub_agent_type)
         if not model_name:
             continue
+
         profile = get_sub_agent_profile(sub_agent_type)
-        if not profile.enabled_for_model(main_client.model_name):
+        if not profile.enabled_for_model(main_model_name):
             continue
-        sub_llm_config = config.get_model_config(model_name)
-        sub_clients[sub_agent_type] = create_llm_client(sub_llm_config)
 
-    return LLMClients(main=main_client, sub_clients=sub_clients)
+        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(sub_agent_type, _factory)
+
+    return 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(
+        child_profile = self._model_profile_provider.build_profile_eager(
             self._llm_clients.get_client(state.sub_agent_type),
             state.sub_agent_type,
         )

klaude_code/core/reminders.py

@@ -344,9 +344,6 @@ async def last_path_memory_reminder(
                     paths.append(path)
             except json.JSONDecodeError:
                 continue
-        elif tool_call.name == tools.BASH:
-            # TODO: haiku check file path
-            pass
     paths = list(set(paths))
     memories: list[Memory] = []
     if len(paths) == 0:

klaude_code/core/task.py

@@ -45,8 +45,8 @@ class MetadataAccumulator:
             acc_usage.output_tokens += usage.output_tokens
             acc_usage.currency = usage.currency
 
-            if usage.context_window_size is not None:
-                acc_usage.context_window_size = usage.context_window_size
+            if usage.context_token is not None:
+                acc_usage.context_token = usage.context_token
             if usage.context_limit is not None:
                 acc_usage.context_limit = usage.context_limit
 

klaude_code/core/tool/file/_utils.py

@@ -0,0 +1,30 @@
+"""Shared utility functions for file tools."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def is_directory(path: str) -> bool:
+    """Check if path is a directory."""
+    return os.path.isdir(path)
+
+
+def file_exists(path: str) -> bool:
+    """Check if path exists."""
+    return os.path.exists(path)
+
+
+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:
+        return f.read()
+
+
+def write_text(path: str, content: str) -> None:
+    """Write text to file, creating parent directories if needed."""
+    parent = Path(path).parent
+    parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(content)

klaude_code/core/tool/file/edit_tool.py

@@ -7,38 +7,13 @@ from pathlib import Path
 
 from pydantic import BaseModel, Field
 
+from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
 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 import llm_param, model, tools
 
 
-def _is_directory(path: str) -> bool:
-    try:
-        return Path(path).is_dir()
-    except Exception:
-        return False
-
-
-def _file_exists(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
-def _read_text(path: str) -> str:
-    with open(path, "r", encoding="utf-8", errors="replace") as f:
-        return f.read()
-
-
-def _write_text(path: str, content: str) -> None:
-    parent = Path(path).parent
-    parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
 @register(tools.EDIT)
 class EditTool(ToolABC):
     class EditArguments(BaseModel):
@@ -119,7 +94,7 @@ class EditTool(ToolABC):
         file_path = os.path.abspath(args.file_path)
 
         # Common file errors
-        if _is_directory(file_path):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
@@ -136,7 +111,7 @@ class EditTool(ToolABC):
 
         # FileTracker checks (only for editing existing files)
         file_tracker = get_current_file_tracker()
-        if not _file_exists(file_path):
+        if not file_exists(file_path):
             # We require reading before editing
             return model.ToolResultItem(
                 status="error",
@@ -163,7 +138,7 @@ class EditTool(ToolABC):
 
         # Edit existing file: validate and apply
         try:
-            before = await asyncio.to_thread(_read_text, file_path)
+            before = await asyncio.to_thread(read_text, file_path)
         except FileNotFoundError:
             return model.ToolResultItem(
                 status="error",
@@ -197,7 +172,7 @@ class EditTool(ToolABC):
 
         # Write back
         try:
-            await asyncio.to_thread(_write_text, file_path, after)
+            await asyncio.to_thread(write_text, file_path, after)
         except Exception as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 

klaude_code/core/tool/file/multi_edit_tool.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from pydantic import BaseModel, Field
 
+from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
 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
@@ -14,32 +15,6 @@ from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
 
-def _is_directory(path: str) -> bool:
-    try:
-        return Path(path).is_dir()
-    except Exception:
-        return False
-
-
-def _file_exists(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
-def _read_text(path: str) -> str:
-    with open(path, "r", encoding="utf-8", errors="replace") as f:
-        return f.read()
-
-
-def _write_text(path: str, content: str) -> None:
-    parent = Path(path).parent
-    parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
 @register(tools.MULTI_EDIT)
 class MultiEditTool(ToolABC):
     class MultiEditEditItem(BaseModel):
@@ -105,7 +80,7 @@ class MultiEditTool(ToolABC):
         file_path = os.path.abspath(args.file_path)
 
         # Directory error first
-        if _is_directory(file_path):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. multi_edit</tool_use_error>",
@@ -114,7 +89,7 @@ class MultiEditTool(ToolABC):
         file_tracker = get_current_file_tracker()
 
         # FileTracker check:
-        if _file_exists(file_path):
+        if file_exists(file_path):
             if file_tracker is not None:
                 tracked = file_tracker.get(file_path)
                 if tracked is None:
@@ -142,8 +117,8 @@ class MultiEditTool(ToolABC):
                 )
 
         # Load initial content (empty for new file case)
-        if _file_exists(file_path):
-            before = await asyncio.to_thread(_read_text, file_path)
+        if file_exists(file_path):
+            before = await asyncio.to_thread(read_text, file_path)
         else:
             before = ""
 
@@ -168,7 +143,7 @@ class MultiEditTool(ToolABC):
 
         # All edits valid; write to disk
         try:
-            await asyncio.to_thread(_write_text, file_path, staged)
+            await asyncio.to_thread(write_text, file_path, staged)
         except Exception as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 

klaude_code/core/tool/file/read_tool.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from pydantic import BaseModel, Field
 
 from klaude_code import const
+from klaude_code.core.tool.file._utils import file_exists, is_directory
 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
@@ -34,20 +35,6 @@ def _format_numbered_line(line_no: int, content: str) -> str:
     return f"{line_no:>6}→{content}"
 
 
-def _is_directory(path: str) -> bool:
-    try:
-        return Path(path).is_dir()
-    except Exception:
-        return False
-
-
-def _file_exists(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
 @dataclass
 class ReadOptions:
     file_path: str
@@ -101,7 +88,7 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
 
 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):
+    if file_tracker is None or not file_exists(file_path) or is_directory(file_path):
         return
     try:
         file_tracker[file_path] = Path(file_path).stat().st_mtime
@@ -188,12 +175,12 @@ class ReadTool(ToolABC):
         char_per_line, line_cap, max_chars, max_kb = cls._effective_limits()
 
         # Common file errors
-        if _is_directory(file_path):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
-        if not _file_exists(file_path):
+        if not file_exists(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>File does not exist.</tool_use_error>",
@@ -222,7 +209,8 @@ class ReadTool(ToolABC):
         # If file is too large and no pagination provided (only check if limits are enabled)
         try:
             size_bytes = Path(file_path).stat().st_size
-        except Exception:
+        except OSError:
+            # Best-effort size detection; on stat errors fall back to treating size as unknown.
             size_bytes = 0
 
         is_image_file = _is_supported_image_file(file_path)

klaude_code/core/tool/file/write_tool.py

@@ -7,38 +7,13 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
+from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
 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 import llm_param, model, tools
 
 
-def _is_directory(path: str) -> bool:
-    try:
-        return Path(path).is_dir()
-    except Exception:
-        return False
-
-
-def _file_exists(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
-def _write_text(path: str, content: str) -> None:
-    parent = Path(path).parent
-    parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
-def _read_text(path: str) -> str:
-    with open(path, "r", encoding="utf-8", errors="replace") as f:
-        return f.read()
-
-
 class WriteArguments(BaseModel):
     file_path: str
     content: str
@@ -78,14 +53,14 @@ class WriteTool(ToolABC):
 
         file_path = os.path.abspath(args.file_path)
 
-        if _is_directory(file_path):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
             )
 
         file_tracker = get_current_file_tracker()
-        exists = _file_exists(file_path)
+        exists = file_exists(file_path)
 
         if exists:
             tracked_mtime: float | None = None
@@ -113,12 +88,12 @@ class WriteTool(ToolABC):
         before = ""
         if exists:
             try:
-                before = await asyncio.to_thread(_read_text, file_path)
+                before = await asyncio.to_thread(read_text, file_path)
             except Exception:
                 before = ""
 
         try:
-            await asyncio.to_thread(_write_text, file_path, args.content)
+            await asyncio.to_thread(write_text, file_path, args.content)
         except Exception as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 

klaude_code/core/tool/memory/__init__.py

@@ -0,0 +1,5 @@
+from .skill_loader import SkillLoader
+from .skill_tool import SkillTool
+
+skill_loader = SkillLoader()
+SkillTool.set_skill_loader(skill_loader)