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

klaude_code/core/prompt.py

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

klaude_code/llm/client.py

@@ -26,6 +26,10 @@ class LLMClientABC(ABC):
     def model_name(self) -> str:
         return self._config.model or ""
 
+    @property
+    def protocol(self) -> llm_param.LLMClientProtocol:
+        return self._config.protocol
+
 
 P = ParamSpec("P")
 R = TypeVar("R")

klaude_code/llm/openrouter/client.py

@@ -15,7 +15,7 @@ from klaude_code.llm.openrouter.reasoning_handler import ReasoningDetail, Reason
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, convert_usage
 from klaude_code.protocol import llm_param, model
-from klaude_code.trace import DebugType, log, log_debug
+from klaude_code.trace import DebugType, is_debug_enabled, log, log_debug
 
 
 def build_payload(
@@ -27,10 +27,11 @@ def build_payload(
 
     extra_body: dict[str, object] = {
         "usage": {"include": True},  # To get the cache tokens at the end of the response
-        "debug": {
-            "echo_upstream_body": True
-        },  # https://openrouter.ai/docs/api/reference/errors-and-debugging#debug-option-shape
     }
+    if is_debug_enabled():
+        extra_body["debug"] = {
+            "echo_upstream_body": True
+        }  # https://openrouter.ai/docs/api/reference/errors-and-debugging#debug-option-shape
     extra_headers: dict[str, str] = {}
 
     if param.thinking:

klaude_code/protocol/events.py

@@ -85,7 +85,6 @@ class ToolCallEvent(BaseModel):
     tool_call_id: str
     tool_name: str
     arguments: str
-    is_replay: bool = False
 
 
 class ToolResultEvent(BaseModel):
@@ -96,7 +95,6 @@ class ToolResultEvent(BaseModel):
     result: str
     ui_extra: model.ToolResultUIExtra | None = None
     status: Literal["success", "error"]
-    is_replay: bool = False
     task_metadata: model.TaskMetadata | None = None  # Sub-agent task metadata
 
 
@@ -136,6 +134,8 @@ class TodoChangeEvent(BaseModel):
 
 HistoryItemEvent = (
     ThinkingEvent
+    | TaskStartEvent
+    | TaskFinishEvent
     | TurnStartEvent  # This event is used for UI to print new empty line
     | AssistantMessageEvent
     | ToolCallEvent

klaude_code/protocol/sub_agent.py

@@ -291,7 +291,6 @@ register_sub_agent(
         tool_set=(tools.BASH, tools.READ),
         prompt_builder=_explore_prompt_builder,
         active_form="Exploring",
-        target_model_filter=lambda model: ("haiku" not in model) and ("kimi" not in model) and ("grok" not in model),
     )
 )
 

klaude_code/session/export.py

@@ -544,7 +544,13 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
 def _build_messages_html(
     history: list[model.ConversationItem],
     tool_results: dict[str, model.ToolResultItem],
+    *,
+    seen_session_ids: set[str] | None = None,
+    nesting_level: int = 0,
 ) -> str:
+    if seen_session_ids is None:
+        seen_session_ids = set()
+
     blocks: list[str] = []
     assistant_counter = 0
 
@@ -596,9 +602,61 @@ def _build_messages_html(
             result = tool_results.get(item.call_id)
             blocks.append(_format_tool_call(item, result))
 
+            # Recursively render sub-agent session history
+            if result is not None:
+                sub_agent_html = _render_sub_agent_session(result, seen_session_ids, nesting_level)
+                if sub_agent_html:
+                    blocks.append(sub_agent_html)
+
     return "\n".join(blocks)
 
 
+def _render_sub_agent_session(
+    tool_result: model.ToolResultItem,
+    seen_session_ids: set[str],
+    nesting_level: int,
+) -> str | None:
+    """Render sub-agent session history when a tool result references it."""
+    from klaude_code.session.session import Session
+
+    ui_extra = tool_result.ui_extra
+    if not isinstance(ui_extra, model.SessionIdUIExtra):
+        return None
+
+    session_id = ui_extra.session_id
+    if not session_id or session_id in seen_session_ids:
+        return None
+
+    seen_session_ids.add(session_id)
+
+    try:
+        sub_session = Session.load(session_id)
+    except Exception:
+        return None
+
+    sub_history = sub_session.conversation_history
+    sub_tool_results = {item.call_id: item for item in sub_history if isinstance(item, model.ToolResultItem)}
+
+    sub_html = _build_messages_html(
+        sub_history,
+        sub_tool_results,
+        seen_session_ids=seen_session_ids,
+        nesting_level=nesting_level + 1,
+    )
+
+    if not sub_html:
+        return None
+
+    # Wrap in a collapsible sub-agent container using same style as other collapsible sections
+    indent_style = f' style="margin-left: {nesting_level * 16}px;"' if nesting_level > 0 else ""
+    return (
+        f'<details class="sub-agent-session"{indent_style}>'
+        f"<summary>Sub-agent: {_escape_html(session_id)}</summary>"
+        f'<div class="sub-agent-content">{sub_html}</div>'
+        f"</details>"
+    )
+
+
 def build_export_html(
     session: Session,
     system_prompt: str,

klaude_code/session/session.py

@@ -267,7 +267,10 @@ class Session(BaseModel):
         )
 
     def get_history_item(self) -> Iterable[events.HistoryItemEvent]:
+        seen_sub_agent_sessions: set[str] = set()
         prev_item: model.ConversationItem | None = None
+        last_assistant_content: str = ""
+        yield events.TaskStartEvent(session_id=self.id, sub_agent_state=self.sub_agent_state)
         for it in self.conversation_history:
             if self.need_turn_start(prev_item, it):
                 yield events.TurnStartEvent(
@@ -276,6 +279,7 @@ class Session(BaseModel):
             match it:
                 case model.AssistantMessageItem() as am:
                     content = am.content or ""
+                    last_assistant_content = content
                     yield events.AssistantMessageEvent(
                         content=content,
                         response_id=am.response_id,
@@ -288,7 +292,6 @@ class Session(BaseModel):
                         arguments=tc.arguments,
                         response_id=tc.response_id,
                         session_id=self.id,
-                        is_replay=True,
                     )
                 case model.ToolResultItem() as tr:
                     yield events.ToolResultEvent(
@@ -298,9 +301,9 @@ class Session(BaseModel):
                         ui_extra=tr.ui_extra,
                         session_id=self.id,
                         status=tr.status,
-                        is_replay=True,
+                        task_metadata=tr.task_metadata,
                     )
-                    # TODO: Replay Sub-Agent Events
+                    yield from self._iter_sub_agent_history(tr, seen_sub_agent_sessions)
                 case model.UserMessageItem() as um:
                     yield events.UserMessageEvent(
                         content=um.content or "",
@@ -333,6 +336,35 @@ class Session(BaseModel):
                 case _:
                     continue
             prev_item = it
+        yield events.TaskFinishEvent(session_id=self.id, task_result=last_assistant_content)
+
+    def _iter_sub_agent_history(
+        self, tool_result: model.ToolResultItem, seen_sub_agent_sessions: set[str]
+    ) -> Iterable[events.HistoryItemEvent]:
+        """Replay sub-agent session history when a tool result references it.
+
+        Sub-agent tool results embed a SessionIdUIExtra containing the child session ID.
+        When present, we load that session and yield its history events so replay/export
+        can show the full sub-agent transcript instead of only the summarized tool output.
+        """
+        ui_extra = tool_result.ui_extra
+        if not isinstance(ui_extra, model.SessionIdUIExtra):
+            return
+
+        session_id = ui_extra.session_id
+        if not session_id or session_id == self.id:
+            return
+        if session_id in seen_sub_agent_sessions:
+            return
+
+        seen_sub_agent_sessions.add(session_id)
+
+        try:
+            sub_session = Session.load(session_id)
+        except Exception:
+            return
+
+        yield from sub_session.get_history_item()
 
     class SessionMetaBrief(BaseModel):
         id: str

klaude_code/session/templates/export_session.html

@@ -886,6 +886,52 @@
         color: var(--text-dim);
       }
 
+      /* Sub-agent Session */
+      details.sub-agent-session {
+        background: transparent;
+        margin: 16px 0;
+        border-left: 3px solid var(--accent);
+        padding-left: 16px;
+      }
+      details.sub-agent-session > summary {
+        padding: 4px 0;
+        font-family: var(--font-mono);
+        font-size: var(--font-size-sm);
+        text-transform: uppercase;
+        font-weight: var(--font-weight-bold);
+        cursor: pointer;
+        user-select: none;
+        list-style: none;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        min-height: 24px;
+        line-height: 1.2;
+        color: var(--text-dim);
+        transition: color 0.2s;
+      }
+      details.sub-agent-session > summary:hover,
+      details.sub-agent-session[open] > summary {
+        color: var(--text);
+      }
+      details.sub-agent-session > summary::-webkit-details-marker {
+        display: none;
+      }
+      details.sub-agent-session > summary::before {
+        content: "[+]";
+        color: var(--accent);
+        font-family: var(--font-mono);
+        margin-right: 4px;
+        display: inline-block;
+        min-width: 24px;
+      }
+      details.sub-agent-session[open] > summary::before {
+        content: "[-]";
+      }
+      details.sub-agent-session > .sub-agent-content {
+        padding: 8px 0 0 0;
+      }
+
       /* Scroll to Bottom Button */
       .scroll-btn {
         position: fixed;

klaude_code/trace/__init__.py

@@ -1,3 +1,3 @@
-from .log import DebugType, is_debug_enabled, log, log_debug, logger, set_debug_logging
+from .log import DebugType, is_debug_enabled, log, log_debug, logger, prepare_debug_log_file, set_debug_logging
 
-__all__ = ["DebugType", "is_debug_enabled", "log", "log_debug", "logger", "set_debug_logging"]
+__all__ = ["DebugType", "is_debug_enabled", "log", "log_debug", "logger", "prepare_debug_log_file", "set_debug_logging"]

klaude_code/trace/log.py

@@ -1,7 +1,13 @@
+import gzip
 import logging
+import os
+import shutil
+import subprocess
 from collections.abc import Iterable
+from datetime import datetime, timedelta
 from enum import Enum
 from logging.handlers import RotatingFileHandler
+from pathlib import Path
 
 from rich.console import Console
 from rich.logging import RichHandler
@@ -49,6 +55,26 @@ _file_handler: RotatingFileHandler | None = None
 _console_handler: RichHandler | None = None
 _debug_filter: DebugTypeFilter | None = None
 _debug_enabled = False
+_current_log_file: Path | None = None
+
+LOG_RETENTION_DAYS = 3
+LOG_MAX_TOTAL_BYTES = 200 * 1024 * 1024
+
+
+class GzipRotatingFileHandler(RotatingFileHandler):
+    """Rotating file handler that gzips rolled files."""
+
+    def rotation_filename(self, default_name: str) -> str:
+        """Append .gz to rotation targets."""
+
+        return f"{default_name}.gz"
+
+    def rotate(self, source: str, dest: str) -> None:
+        """Compress the rotated file and remove the original."""
+
+        with open(source, "rb") as source_file, gzip.open(dest, "wb") as dest_file:
+            shutil.copyfileobj(source_file, dest_file)
+        Path(source).unlink(missing_ok=True)
 
 
 def set_debug_logging(
@@ -66,7 +92,7 @@ def set_debug_logging(
         log_file: Path to the log file (default: debug.log)
         filters: Set of DebugType to include; None means all types
     """
-    global _file_handler, _console_handler, _debug_filter, _debug_enabled
+    global _file_handler, _console_handler, _debug_filter, _debug_enabled, _current_log_file
 
     _debug_enabled = enabled
 
@@ -80,6 +106,7 @@ def set_debug_logging(
         _console_handler = None
 
     if not enabled:
+        _current_log_file = None
         return
 
     # Create filter
@@ -87,10 +114,19 @@ def set_debug_logging(
 
     # Determine output mode
     use_file = write_to_file if write_to_file is not None else True
-    file_path = log_file if log_file is not None else const.DEFAULT_DEBUG_LOG_FILE
-
     if use_file:
-        _file_handler = RotatingFileHandler(
+        if _current_log_file is None:
+            _current_log_file = _resolve_log_file(log_file)
+        file_path = _current_log_file
+    else:
+        _current_log_file = None
+        file_path = None
+
+    if use_file and file_path is not None:
+        _prune_old_logs(const.DEFAULT_DEBUG_LOG_DIR, LOG_RETENTION_DAYS, LOG_MAX_TOTAL_BYTES)
+
+    if use_file and file_path is not None:
+        _file_handler = GzipRotatingFileHandler(
             file_path,
             maxBytes=const.LOG_MAX_BYTES,
             backupCount=const.LOG_BACKUP_COUNT,
@@ -166,3 +202,106 @@ def _build_message(objects: Iterable[str | tuple[str, str]]) -> str:
 def is_debug_enabled() -> bool:
     """Check if debug logging is currently enabled."""
     return _debug_enabled
+
+
+def prepare_debug_log_file(log_file: str | os.PathLike[str] | None = None) -> Path:
+    """Prepare and remember the log file path for this session."""
+
+    global _current_log_file
+    _current_log_file = _resolve_log_file(log_file)
+    return _current_log_file
+
+
+def get_current_log_file() -> Path | None:
+    """Return the currently active log file path, if any."""
+
+    return _current_log_file
+
+
+def _resolve_log_file(log_file: str | os.PathLike[str] | None) -> Path:
+    """Resolve the log file path and ensure directories exist."""
+
+    if log_file:
+        path = Path(log_file).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+    else:
+        path = _build_default_log_file_path()
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch(exist_ok=True)
+    _refresh_latest_symlink(path)
+    return path
+
+
+def _build_default_log_file_path() -> Path:
+    """Build a per-session log path under the default log directory."""
+
+    now = datetime.now()
+    session_dir = const.DEFAULT_DEBUG_LOG_DIR / now.strftime("%Y-%m-%d")
+    session_dir.mkdir(parents=True, exist_ok=True)
+    filename = f"{now.strftime('%H%M%S')}-{os.getpid()}.log"
+    return session_dir / filename
+
+
+def _refresh_latest_symlink(target: Path) -> None:
+    """Point the debug.log symlink at the latest session file."""
+
+    latest = const.DEFAULT_DEBUG_LOG_FILE
+    try:
+        latest.unlink(missing_ok=True)
+        latest.symlink_to(target)
+    except OSError:
+        # Non-blocking best-effort; logging should still proceed
+        return
+
+
+def _prune_old_logs(log_root: Path, keep_days: int, max_total_bytes: int) -> None:
+    """Remove logs older than keep_days or when exceeding max_total_bytes."""
+
+    if not log_root.exists():
+        return
+
+    cutoff = datetime.now() - timedelta(days=keep_days)
+    files: list[Path] = [p for p in log_root.rglob("*") if p.is_file() and not p.is_symlink()]
+
+    # Remove by age
+    for path in files:
+        try:
+            mtime = datetime.fromtimestamp(path.stat().st_mtime)
+        except OSError:
+            continue
+        if mtime < cutoff:
+            _trash_path(path)
+
+    # Recompute remaining files and sizes
+    remaining: list[tuple[Path, float, int]] = []
+    total_size = 0
+    for path in log_root.rglob("*"):
+        if not path.is_file() or path.is_symlink():
+            continue
+        try:
+            stat = path.stat()
+        except OSError:
+            continue
+        remaining.append((path, stat.st_mtime, stat.st_size))
+        total_size += stat.st_size
+
+    if total_size <= max_total_bytes:
+        return
+
+    remaining.sort(key=lambda item: item[1])
+    for path, _, size in remaining:
+        _trash_path(path)
+        total_size -= size
+        if total_size <= max_total_bytes:
+            break
+
+
+def _trash_path(path: Path) -> None:
+    """Send a path to trash, falling back to unlink if trash is unavailable."""
+
+    try:
+        subprocess.run(["trash", str(path)], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except FileNotFoundError:
+        path.unlink(missing_ok=True)

klaude_code/ui/modes/debug/display.py

@@ -1,3 +1,4 @@
+import os
 from typing import override
 
 from klaude_code import const
@@ -10,7 +11,7 @@ class DebugEventDisplay(DisplayABC):
     def __init__(
         self,
         wrapped_display: DisplayABC | None = None,
-        log_file: str = const.DEFAULT_DEBUG_LOG_FILE,
+        log_file: str | os.PathLike[str] = const.DEFAULT_DEBUG_LOG_FILE,
     ):
         self.wrapped_display = wrapped_display
         self.log_file = log_file

klaude_code/ui/modes/repl/completers.py

@@ -67,12 +67,12 @@ class _SlashCommandCompleter(Completer):
     ) -> Iterable[Completion]:
         # Only complete on first line
         if document.cursor_position_row != 0:
-            return iter([])
+            return
 
         text_before = document.current_line_before_cursor
         m = self._SLASH_TOKEN_RE.search(text_before)
         if not m:
-            return iter([])
+            return
 
         frag = m.group("frag")
         token_start = len(text_before) - len(f"/{frag}")
@@ -89,7 +89,7 @@ class _SlashCommandCompleter(Completer):
                 matched.append((cmd_name, cmd_obj, hint))
 
         if not matched:
-            return iter([])
+            return
 
         # Calculate max width for alignment
         # Find the longest command+hint length