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

klaude_code/core/prompt.py

@@ -26,9 +26,34 @@ PROMPT_FILES: dict[str, str] = {
 
 
 @lru_cache(maxsize=None)
-def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
-    """Get system prompt content for the given model and sub-agent type."""
+def _load_base_prompt(file_key: str) -> str:
+    """Load and cache the base prompt content from file."""
+    try:
+        prompt_path = PROMPT_FILES[file_key]
+    except KeyError as exc:
+        raise ValueError(f"Unknown prompt key: {file_key}") from exc
+
+    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:
+    """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":
+            return "main_gpt_5_1_codex_max"
+        case name if "gpt-5" in name:
+            return "main_gpt_5_1"
+        case name if "gemini" in name:
+            return "main_gemini"
+        case _:
+            return "main_claude"
+
+
+def _build_env_info(model_name: str) -> str:
+    """Build environment info section with dynamic runtime values."""
     cwd = Path.cwd()
     today = datetime.datetime.now().strftime("%Y-%m-%d")
     is_git_repo = (cwd / ".git").exists()
@@ -38,30 +63,6 @@ def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str
         if shutil.which(command) is not None:
             available_tools.append(f"{command}: {desc}")
 
-    if sub_agent_type is None:
-        match model_name:
-            case "gpt-5.1-codex-max":
-                file_key = "main_gpt_5_1_codex_max"
-            case name if "gpt-5" in name:
-                file_key = "main_gpt_5_1"
-            case name if "gemini" in name:
-                file_key = "main_gemini"
-            case _:
-                file_key = "main_claude"
-    else:
-        file_key = sub_agent_type
-
-    try:
-        prompt_path = PROMPT_FILES[file_key]
-    except KeyError as exc:
-        raise ValueError(f"Unknown prompt key: {file_key}") from exc
-
-    base_prompt = files(__package__).joinpath(prompt_path).read_text(encoding="utf-8").strip()
-
-    if model_name == "gpt-5.1-codex-max":
-        # Do not add env info for gpt-5.1-codex-max
-        return base_prompt
-
     env_lines: list[str] = [
         "",
         "",
@@ -80,6 +81,15 @@ def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str
 
     env_lines.append("</env>")
 
-    env_info = "\n".join(env_lines)
+    return "\n".join(env_lines)
+
+
+def get_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)
+
+    if model_name == "gpt-5.1-codex-max":
+        return base_prompt
 
-    return base_prompt + env_info
+    return base_prompt + _build_env_info(model_name)

klaude_code/core/reminders.py

@@ -150,16 +150,16 @@ async def todo_not_used_recently_reminder(
         return None
 
     # Count non-todo tool calls since the last TodoWrite
-    other_tool_call_count_befor_last_todo = 0
+    other_tool_call_count_before_last_todo = 0
     for item in reversed(session.conversation_history):
         if isinstance(item, model.ToolCallItem):
             if item.name in (tools.TODO_WRITE, tools.UPDATE_PLAN):
                 break
-            other_tool_call_count_befor_last_todo += 1
-            if other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
+            other_tool_call_count_before_last_todo += 1
+            if other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
                 break
 
-    not_used_recently = other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
+    not_used_recently = other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
 
     if not not_used_recently:
         return None
@@ -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

@@ -25,28 +25,30 @@ class MetadataAccumulator:
     """
 
     def __init__(self, model_name: str) -> None:
-        self._accumulated = model.ResponseMetadataItem(model_name=model_name)
+        self._main = model.TaskMetadata(model_name=model_name)
+        self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
 
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
-        accumulated = self._accumulated
+        main = self._main
         usage = turn_metadata.usage
 
         if usage is not None:
-            if accumulated.usage is None:
-                accumulated.usage = model.Usage()
-            acc_usage = accumulated.usage
+            if main.usage is None:
+                main.usage = model.Usage()
+            acc_usage = main.usage
             acc_usage.input_tokens += usage.input_tokens
             acc_usage.cached_tokens += usage.cached_tokens
             acc_usage.reasoning_tokens += usage.reasoning_tokens
             acc_usage.output_tokens += usage.output_tokens
-            acc_usage.total_tokens += usage.total_tokens
             acc_usage.currency = usage.currency
 
-            if usage.context_usage_percent is not None:
-                acc_usage.context_usage_percent = usage.context_usage_percent
+            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
 
             if usage.first_token_latency_ms is not None:
                 if acc_usage.first_token_latency_ms is None:
@@ -63,47 +65,56 @@ class MetadataAccumulator:
                     self._throughput_weighted_sum += usage.throughput_tps * current_output
                     self._throughput_tracked_tokens += current_output
 
-            # Accumulate costs
             if usage.input_cost is not None:
                 acc_usage.input_cost = (acc_usage.input_cost or 0.0) + usage.input_cost
             if usage.output_cost is not None:
                 acc_usage.output_cost = (acc_usage.output_cost or 0.0) + usage.output_cost
             if usage.cache_read_cost is not None:
                 acc_usage.cache_read_cost = (acc_usage.cache_read_cost or 0.0) + usage.cache_read_cost
-            if usage.total_cost is not None:
-                acc_usage.total_cost = (acc_usage.total_cost or 0.0) + usage.total_cost
 
         if turn_metadata.provider is not None:
-            accumulated.provider = turn_metadata.provider
+            main.provider = turn_metadata.provider
         if turn_metadata.model_name:
-            accumulated.model_name = turn_metadata.model_name
-        if turn_metadata.response_id:
-            accumulated.response_id = turn_metadata.response_id
+            main.model_name = turn_metadata.model_name
 
-    def finalize(self, task_duration_s: float) -> model.ResponseMetadataItem:
+    def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
+        """Add sub-agent task metadata to the accumulated state."""
+        self._sub_agent_metadata.append(sub_agent_metadata)
+
+    def finalize(self, task_duration_s: float) -> model.TaskMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""
-        accumulated = self._accumulated
-        if accumulated.usage is not None:
+        main = self._main
+        if main.usage is not None:
             if self._throughput_tracked_tokens > 0:
-                accumulated.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
+                main.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
             else:
-                accumulated.usage.throughput_tps = None
+                main.usage.throughput_tps = None
 
-        accumulated.task_duration_s = task_duration_s
-        return accumulated
+        main.task_duration_s = task_duration_s
+        return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
 
 
 @dataclass
-class TaskExecutionContext:
-    """Execution context required to run a task."""
+class SessionContext:
+    """Shared session-level context for task and turn execution.
+
+    Contains common fields that both TaskExecutionContext and TurnExecutionContext need.
+    """
 
     session_id: str
-    profile: AgentProfile
     get_conversation_history: Callable[[], list[model.ConversationItem]]
     append_history: Callable[[Sequence[model.ConversationItem]], None]
-    tool_registry: dict[str, type[ToolABC]]
     file_tracker: MutableMapping[str, float]
     todo_context: TodoContext
+
+
+@dataclass
+class TaskExecutionContext:
+    """Execution context required to run a task."""
+
+    session_ctx: SessionContext
+    profile: AgentProfile
+    tool_registry: dict[str, type[ToolABC]]
     # For reminder processing - needs access to session
     process_reminder: Callable[[Reminder], AsyncGenerator[events.DeveloperMessageEvent, None]]
     sub_agent_state: model.SubAgentState | None
@@ -135,18 +146,18 @@ class TaskExecutor:
     async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event, None]:
         """Execute the task, yielding events as they occur."""
         ctx = self._context
+        session_ctx = ctx.session_ctx
         self._started_at = time.perf_counter()
 
         yield events.TaskStartEvent(
-            session_id=ctx.session_id,
+            session_id=session_ctx.session_id,
             sub_agent_state=ctx.sub_agent_state,
         )
 
-        ctx.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        session_ctx.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
 
         profile = ctx.profile
         metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
-        last_assistant_message: events.AssistantMessageEvent | None = None
 
         while True:
             # Process reminders at the start of each turn
@@ -155,15 +166,11 @@ class TaskExecutor:
                     yield event
 
             turn_context = TurnExecutionContext(
-                session_id=ctx.session_id,
-                get_conversation_history=ctx.get_conversation_history,
-                append_history=ctx.append_history,
+                session_ctx=session_ctx,
                 llm_client=profile.llm_client,
                 system_prompt=profile.system_prompt,
                 tools=profile.tools,
                 tool_registry=ctx.tool_registry,
-                file_tracker=ctx.file_tracker,
-                todo_context=ctx.todo_context,
             )
 
             turn: TurnExecutor | None = None
@@ -178,11 +185,14 @@ class TaskExecutor:
                     async for turn_event in turn.run():
                         match turn_event:
                             case events.AssistantMessageEvent() as am:
-                                if am.content.strip() != "":
-                                    last_assistant_message = am
                                 yield am
                             case events.ResponseMetadataEvent() as e:
                                 metadata_accumulator.add(e.metadata)
+                            case events.ToolResultEvent() as e:
+                                # Collect sub-agent task metadata from tool results
+                                if e.task_metadata is not None:
+                                    metadata_accumulator.add_sub_agent_metadata(e.task_metadata)
+                                yield turn_event
                             case _:
                                 yield turn_event
 
@@ -219,14 +229,23 @@ class TaskExecutor:
         task_duration_s = time.perf_counter() - self._started_at
         accumulated = metadata_accumulator.finalize(task_duration_s)
 
-        yield events.ResponseMetadataEvent(metadata=accumulated, session_id=ctx.session_id)
-        ctx.append_history([accumulated])
+        yield events.TaskMetadataEvent(metadata=accumulated, session_id=session_ctx.session_id)
+        session_ctx.append_history([accumulated])
         yield events.TaskFinishEvent(
-            session_id=ctx.session_id,
-            task_result=last_assistant_message.content if last_assistant_message else "",
+            session_id=session_ctx.session_id,
+            task_result=_get_last_assistant_message(session_ctx.get_conversation_history()) or "",
         )
 
 
+def _get_last_assistant_message(history: list[model.ConversationItem]) -> str | None:
+    """Return the content of the most recent assistant message in history."""
+
+    for item in reversed(history):
+        if isinstance(item, model.AssistantMessageItem):
+            return item.content or ""
+    return None
+
+
 def _retry_delay_seconds(attempt: int) -> float:
     """Compute exponential backoff delay for the given attempt count."""
     capped_attempt = max(1, attempt)

klaude_code/core/tool/__init__.py

@@ -16,6 +16,7 @@ from .tool_abc import ToolABC
 from .tool_context import (
     TodoContext,
     ToolContextToken,
+    build_todo_context,
     current_run_subtask_callback,
     reset_tool_context,
     set_tool_context_from_session,
@@ -46,6 +47,7 @@ __all__ = [
     "ToolABC",
     # Tool context
     "TodoContext",
+    "build_todo_context",
     "ToolContextToken",
     "current_run_subtask_callback",
     "reset_tool_context",

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/apply_patch_tool.py

@@ -26,7 +26,7 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text),
+            ui_extra=model.DiffTextUIExtra(diff_text=diff_text),
         )
 
     @staticmethod

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>")
 
@@ -212,7 +187,7 @@ class EditTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         # Update tracker with new mtime
         if file_tracker is not None:

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>")
 
@@ -183,7 +158,7 @@ class MultiEditTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         # Update tracker
         if file_tracker is not None:

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)