klaude-code 1.2.9__py3-none-any.whl → 1.2.11__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,14 @@ 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
+        self._prev_context_token: int = 0  # Track context size from previous task for delta calculation
+        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.
@@ -125,6 +170,12 @@ class Agent:
 
         try:
             async for event in task.run(user_input):
+                # Compute context_delta for TaskMetadataEvent
+                if isinstance(event, events.TaskMetadataEvent):
+                    usage = event.metadata.main.usage
+                    if usage is not None and usage.context_token is not None:
+                        usage.context_delta = usage.context_token - self._prev_context_token
+                        self._prev_context_token = usage.context_token
                 yield event
         finally:
             self._current_task = None
@@ -148,11 +199,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

@@ -114,9 +114,6 @@ class ExecutorContext:
 
     async def handle_init_agent(self, operation: op.InitAgentOperation) -> None:
         """Initialize an agent for a session and replay history to UI."""
-        if operation.session_id is None:
-            raise ValueError("session_id cannot be None")
-
         await self.agent_manager.ensure_agent(operation.session_id)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
@@ -482,4 +479,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,21 @@ class AgentManager:
 
         await self._event_queue.put(event)
 
-    async def ensure_agent(self, session_id: str) -> 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)
+    async def ensure_agent(self, session_id: str | None = None) -> Agent:
+        """Return an existing agent for the session or create a new one.
+
+        If session_id is None, a new session is created with an auto-generated ID.
+        If session_id is provided, attempts to load existing session or creates new one.
+        """
+        if session_id is None:
+            session = Session.create()
+        else:
+            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)
+        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,13 +60,13 @@ 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(),
             )
         )
 
-        self._active_agents[session_id] = agent
+        self._active_agents[session.id] = agent
         log_debug(
-            f"Initialized agent for session: {session_id}",
+            f"Initialized agent for session: {session.id}",
             style="cyan",
             debug_type=DebugType.EXECUTION,
         )
@@ -76,7 +81,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

@@ -6,8 +6,7 @@ from klaude_code.config import Config
 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 get_sub_agent_profile
-from klaude_code.protocol.tools import SubAgentType
+from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -15,7 +14,6 @@ def build_llm_clients(
     config: Config,
     *,
     model_override: str | None = None,
-    enabled_sub_agents: list[SubAgentType] | None = None,
 ) -> LLMClients:
     """Create an ``LLMClients`` bundle driven by application config."""
 
@@ -32,18 +30,29 @@ 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)
 
-    # Initialize sub-agent clients
-    for sub_agent_type in enabled_sub_agents or []:
-        model_name = config.subagent_models.get(sub_agent_type)
+    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,
+    )
+
+    for profile in iter_sub_agent_profiles():
+        model_name = config.subagent_models.get(profile.name)
         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(profile.name, _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/prompt.py

@@ -6,8 +6,8 @@ from pathlib import Path
 
 COMMAND_DESCRIPTIONS: dict[str, str] = {
     "rg": "ripgrep - fast text search",
-    "fd": "fd - simple and fast alternative to find",
-    "tree": "tree - directory listing as a tree",
+    "fd": "simple and fast alternative to find",
+    "tree": "directory listing as a tree",
     "sg": "ast-grep - AST-aware code search",
 }
 
@@ -15,7 +15,7 @@ COMMAND_DESCRIPTIONS: dict[str, str] = {
 PROMPT_FILES: dict[str, str] = {
     "main_gpt_5_1": "prompts/prompt-codex-gpt-5-1.md",
     "main_gpt_5_1_codex_max": "prompts/prompt-codex-gpt-5-1-codex-max.md",
-    "main_claude": "prompts/prompt-claude-code.md",
+    "main": "prompts/prompt-claude-code.md",
     "main_gemini": "prompts/prompt-gemini.md",  # https://ai.google.dev/gemini-api/docs/prompting-strategies?hl=zh-cn#agentic-si-template
     # Sub-agent prompts keyed by their name
     "Task": "prompts/prompt-subagent.md",
@@ -49,7 +49,7 @@ def _get_file_key(model_name: str, sub_agent_type: str | None) -> str:
         case name if "gemini" in name:
             return "main_gemini"
         case _:
-            return "main_claude"
+            return "main"
 
 
 def _build_env_info(model_name: str) -> str:

klaude_code/core/prompts/prompt-claude-code.md

@@ -84,15 +84,4 @@ assistant: [Uses the Explore tool to find the files that handle client errors in
 <example>
 user: What is the codebase structure?
 assistant: [Uses the Explore tool]
-</example>
-
-## Memory
-MEMORY PROTOCOL:
-1. Use the `view` command of your `Memory` tool to check for earlier progress.
-2. ... (work on the task) ...
-     - As you make progress, record status / progress / thoughts etc in your memory.
-ASSUME INTERRUPTION: Your context window might be reset at any moment, so you risk losing any progress that is not recorded in your memory directory.
-
-Note: when editing your memory folder, always try to keep its content up-to-date, coherent and organized. You can rename or delete files that are no longer relevant. Do not create new files unless necessary.
-
-Only write down information relevant to current project in your memory system.
+</example>

klaude_code/core/prompts/prompt-minimal.md

@@ -0,0 +1,12 @@
+You are an interactive CLI tool. Use the tools available to you to assist the user.
+
+## Guidelines
+- Never use emojis.
+- Your output will be displayed on a command line interface. Your responses should be short and concise.
+- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+- NEVER create Markdown files unless they're absolutely necessary for achieving your goal.
+- Use TodoWrite tool to help you manage and plan tasks.
+- For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+
+## Professional objectivity
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if you honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. Avoid using over-the-top validation or excessive praise when responding to users such as "You're absolutely right" or similar phrases.

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

@@ -29,9 +29,11 @@ class MetadataAccumulator:
         self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
+        self._turn_count: int = 0
 
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
+        self._turn_count += 1
         main = self._main
         usage = turn_metadata.usage
 
@@ -43,10 +45,11 @@ 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_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
 
@@ -91,6 +94,7 @@ class MetadataAccumulator:
                 main.usage.throughput_tps = None
 
         main.task_duration_s = task_duration_s
+        main.turn_count = self._turn_count
         return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
 
 

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>")