klaude-code 2.5.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

klaude_code/protocol/events.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import time
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from klaude_code.protocol import llm_param, message, model
+from klaude_code.protocol.commands import CommandName
+
+__all__ = [
+    "AssistantImageDeltaEvent",
+    "AssistantTextDeltaEvent",
+    "AssistantTextEndEvent",
+    "AssistantTextStartEvent",
+    "CommandOutputEvent",
+    "DeveloperMessageEvent",
+    "EndEvent",
+    "ErrorEvent",
+    "Event",
+    "InterruptEvent",
+    "ReplayEventUnion",
+    "ReplayHistoryEvent",
+    "ResponseCompleteEvent",
+    "ResponseEvent",
+    "TaskFinishEvent",
+    "TaskMetadataEvent",
+    "TaskStartEvent",
+    "ThinkingDeltaEvent",
+    "ThinkingEndEvent",
+    "ThinkingStartEvent",
+    "TodoChangeEvent",
+    "ToolCallEvent",
+    "ToolCallStartEvent",
+    "ToolResultEvent",
+    "TurnEndEvent",
+    "TurnStartEvent",
+    "UsageEvent",
+    "UserMessageEvent",
+    "WelcomeEvent",
+]
+
+
+class Event(BaseModel):
+    """Base event."""
+
+    session_id: str
+    timestamp: float = Field(default_factory=time.time)
+
+
+class ResponseEvent(Event):
+    """Event associated with a single model response."""
+
+    response_id: str | None = None
+
+
+class UserMessageEvent(Event):
+    content: str
+    images: list[message.ImageURLPart] | None = None
+
+
+class DeveloperMessageEvent(Event):
+    """DeveloperMessages are reminders in user messages or tool results."""
+
+    item: message.DeveloperMessage
+
+
+class TodoChangeEvent(Event):
+    todos: list[model.TodoItem]
+
+
+class CommandOutputEvent(Event):
+    """Event for command output display. Not persisted to session history."""
+
+    command_name: CommandName | str
+    content: str = ""
+    ui_extra: model.ToolResultUIExtra | None = None
+    is_error: bool = False
+
+
+class TaskStartEvent(Event):
+    sub_agent_state: model.SubAgentState | None = None
+    model_id: str | None = None
+
+
+class TaskFinishEvent(Event):
+    task_result: str
+    has_structured_output: bool = False
+
+
+class TurnStartEvent(Event):
+    pass
+
+
+class TurnEndEvent(Event):
+    pass
+
+
+class UsageEvent(ResponseEvent):
+    usage: model.Usage
+
+
+class TaskMetadataEvent(Event):
+    metadata: model.TaskMetadataItem
+    cancelled: bool = False
+
+
+class ThinkingStartEvent(ResponseEvent):
+    pass
+
+
+class ThinkingDeltaEvent(ResponseEvent):
+    content: str
+
+
+class ThinkingEndEvent(ResponseEvent):
+    pass
+
+
+class AssistantTextStartEvent(ResponseEvent):
+    pass
+
+
+class AssistantTextDeltaEvent(ResponseEvent):
+    content: str
+
+
+class AssistantTextEndEvent(ResponseEvent):
+    pass
+
+
+class AssistantImageDeltaEvent(ResponseEvent):
+    file_path: str
+
+
+class ToolCallStartEvent(ResponseEvent):
+    tool_call_id: str
+    tool_name: str
+
+
+class ResponseCompleteEvent(ResponseEvent):
+    """Final snapshot of the model response."""
+
+    content: str
+    thinking_text: str | None = None
+
+
+class WelcomeEvent(Event):
+    work_dir: str
+    llm_config: llm_param.LLMConfigParameter
+    show_klaude_code_info: bool = True
+    loaded_skills: dict[str, list[str]] = Field(default_factory=dict)
+
+
+class ErrorEvent(Event):
+    error_message: str
+    can_retry: bool = False
+
+
+class InterruptEvent(Event):
+    pass
+
+
+class EndEvent(Event):
+    """Global display shutdown."""
+
+    session_id: str = "__app__"
+
+
+type ReplayEventUnion = (
+    TaskStartEvent
+    | TaskFinishEvent
+    | TurnStartEvent
+    | ThinkingStartEvent
+    | ThinkingDeltaEvent
+    | ThinkingEndEvent
+    | AssistantTextStartEvent
+    | AssistantTextDeltaEvent
+    | AssistantTextEndEvent
+    | AssistantImageDeltaEvent
+    | ToolCallEvent
+    | ToolResultEvent
+    | UserMessageEvent
+    | TaskMetadataEvent
+    | InterruptEvent
+    | DeveloperMessageEvent
+    | ErrorEvent
+)
+
+
+class ReplayHistoryEvent(Event):
+    events: list[ReplayEventUnion]
+    updated_at: float
+    is_load: bool = True
+
+
+class ToolCallEvent(ResponseEvent):
+    tool_call_id: str
+    tool_name: str
+    arguments: str
+
+
+class ToolResultEvent(ResponseEvent):
+    tool_call_id: str
+    tool_name: str
+    result: str
+    ui_extra: model.ToolResultUIExtra | None = None
+    status: Literal["success", "error", "aborted"]
+    task_metadata: model.TaskMetadata | None = None
+    is_last_in_turn: bool = True
+
+    @property
+    def is_error(self) -> bool:
+        return self.status in ("error", "aborted")

klaude_code/protocol/sub_agent/image_gen.py

@@ -66,10 +66,6 @@ IMAGE_GEN_PARAMETERS: dict[str, Any] = {
                     "enum": ["1K", "2K", "4K"],
                     "description": "Output size for Nano Banana Pro (must use uppercase K).",
                 },
-                "extra": {
-                    "type": "object",
-                    "description": "Provider/model-specific extra parameters (future-proofing).",
-                },
             },
             "additionalProperties": False,
         },

klaude_code/session/session.py

@@ -304,24 +304,57 @@ class Session(BaseModel):
                 yield events.TurnStartEvent(session_id=self.id)
             match it:
                 case message.AssistantMessage() as am:
-                    content = message.join_text_parts(am.parts)
-                    images = [part for part in am.parts if isinstance(part, message.ImageFilePart)]
-                    last_assistant_content = message.format_saved_images(images, content)
-                    thinking_text = "".join(
-                        part.text for part in am.parts if isinstance(part, message.ThinkingTextPart)
-                    )
-                    for image in images:
-                        yield events.AssistantImageDeltaEvent(
-                            file_path=image.file_path,
-                            response_id=am.response_id,
-                            session_id=self.id,
-                        )
-                    yield events.ResponseCompleteEvent(
-                        thinking_text=thinking_text or None,
-                        content=content,
-                        response_id=am.response_id,
-                        session_id=self.id,
-                    )
+                    all_images = [part for part in am.parts if isinstance(part, message.ImageFilePart)]
+                    full_content = message.join_text_parts(am.parts)
+                    last_assistant_content = message.format_saved_images(all_images, full_content)
+
+                    # Reconstruct streaming boundaries from saved parts.
+                    # This allows replay to reuse the same TUI state machine as live events.
+                    thinking_open = False
+                    assistant_open = False
+
+                    for part in am.parts:
+                        if isinstance(part, message.ThinkingTextPart):
+                            if assistant_open:
+                                assistant_open = False
+                                yield events.AssistantTextEndEvent(response_id=am.response_id, session_id=self.id)
+                            if not thinking_open:
+                                thinking_open = True
+                                yield events.ThinkingStartEvent(response_id=am.response_id, session_id=self.id)
+                            if part.text:
+                                yield events.ThinkingDeltaEvent(
+                                    content=part.text,
+                                    response_id=am.response_id,
+                                    session_id=self.id,
+                                )
+                            continue
+
+                        if thinking_open:
+                            thinking_open = False
+                            yield events.ThinkingEndEvent(response_id=am.response_id, session_id=self.id)
+
+                        if isinstance(part, message.TextPart):
+                            if not assistant_open:
+                                assistant_open = True
+                                yield events.AssistantTextStartEvent(response_id=am.response_id, session_id=self.id)
+                            if part.text:
+                                yield events.AssistantTextDeltaEvent(
+                                    content=part.text,
+                                    response_id=am.response_id,
+                                    session_id=self.id,
+                                )
+                        elif isinstance(part, message.ImageFilePart):
+                            yield events.AssistantImageDeltaEvent(
+                                file_path=part.file_path,
+                                response_id=am.response_id,
+                                session_id=self.id,
+                            )
+
+                    if thinking_open:
+                        yield events.ThinkingEndEvent(response_id=am.response_id, session_id=self.id)
+                    if assistant_open:
+                        yield events.AssistantTextEndEvent(response_id=am.response_id, session_id=self.id)
+
                     for part in am.parts:
                         if not isinstance(part, message.ToolCallPart):
                             continue

klaude_code/skill/loader.py

@@ -209,22 +209,21 @@ class SkillLoader:
         """Get list of all loaded skill names"""
         return list(self.loaded_skills.keys())
 
-    def get_skills_xml(self) -> str:
-        """Generate Level 1 metadata in XML format for tool description
+    def get_skills_yaml(self) -> str:
+        """Generate skill metadata in YAML format for system prompt.
 
         Returns:
-            XML string with all skill metadata
+            YAML string with all skill metadata
         """
-        xml_parts: list[str] = []
-        # Prefer showing higher-priority skills first (project > user > system).
+        yaml_parts: list[str] = []
         location_order = {"project": 0, "user": 1, "system": 2}
         for skill in sorted(self.loaded_skills.values(), key=lambda s: location_order.get(s.location, 3)):
-            xml_parts.append(
-                f"""<skill>
-<name>{skill.name}</name>
-<description>{skill.description}</description>
-<scope>{skill.location}</scope>
-<location>{skill.skill_path}</location>
-</skill>"""
+            # Escape description for YAML (handle multi-line and special chars)
+            desc = skill.description.replace("\n", " ").strip()
+            yaml_parts.append(
+                f"- name: {skill.name}\n"
+                f"  description: {desc}\n"
+                f"  scope: {skill.location}\n"
+                f"  location: {skill.skill_path}"
             )
-        return "\n".join(xml_parts)
+        return "\n".join(yaml_parts)

klaude_code/skill/manager.py

@@ -80,8 +80,8 @@ def format_available_skills_for_system_prompt() -> str:
 
     try:
         loader = _ensure_initialized()
-        skills_xml = loader.get_skills_xml().strip()
-        if not skills_xml:
+        skills_yaml = loader.get_skills_yaml().strip()
+        if not skills_yaml:
             return ""
 
         return f"""
@@ -102,7 +102,7 @@ Important:
 The list below is metadata only (name/description/location). The full instructions live in the referenced file.
 
 <available_skills>
-{skills_xml}
+{skills_yaml}
 </available_skills>"""
     except Exception:
         # Skills are an optional enhancement; do not fail prompt construction if discovery breaks.

klaude_code/tui/command/__init__.py

@@ -40,7 +40,6 @@ def ensure_commands_loaded() -> None:
     from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
     from .sub_agent_model_cmd import SubAgentModelCommand
-    from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
@@ -55,7 +54,6 @@ def ensure_commands_loaded() -> None:
     register(StatusCommand())
     register(ResumeCommand())
     register(ExportOnlineCommand())
-    register(TerminalSetupCommand())
     register(DebugCommand())
     register(ClearCommand())
 
@@ -76,7 +74,6 @@ def __getattr__(name: str) -> object:
         "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
         "SubAgentModelCommand": "sub_agent_model_cmd",
-        "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",
     }
     if name in _commands_map:
@@ -91,7 +88,7 @@ __all__ = [
     # Command classes are lazily loaded via __getattr__
     # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
     # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
-    # "StatusCommand", "TerminalSetupCommand",
+    # "StatusCommand",
     "CommandABC",
     "CommandResult",
     "dispatch_command",

klaude_code/tui/command/copy_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.protocol import commands, events, message
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult
 

klaude_code/tui/command/fork_session_cmd.py

@@ -6,7 +6,7 @@ from typing import Literal
 from prompt_toolkit.styles import Style, merge_styles
 
 from klaude_code.protocol import commands, events, message, model
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -194,7 +194,7 @@ class ForkSessionCommand(CommandABC):
 
     @property
     def summary(self) -> str:
-        return "Fork the current session and show a resume-by-id command"
+        return "Fork the current session and show a resume command"
 
     @property
     def is_interactive(self) -> bool:
@@ -220,7 +220,7 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
-            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            resume_cmd = f"klaude --resume {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
             event = events.CommandOutputEvent(
@@ -249,7 +249,7 @@ class ForkSessionCommand(CommandABC):
         # Build result message
         fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
-        resume_cmd = f"klaude --resume-by-id {new_session.id}"
+        resume_cmd = f"klaude --resume {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
         event = events.CommandOutputEvent(

klaude_code/tui/commands.py

@@ -13,11 +13,6 @@ class RenderCommand:
     pass
 
 
-@dataclass(frozen=True, slots=True)
-class RenderReplayHistory(RenderCommand):
-    event: events.ReplayHistoryEvent
-
-
 @dataclass(frozen=True, slots=True)
 class RenderWelcome(RenderCommand):
     event: events.WelcomeEvent

klaude_code/tui/components/command_output.py

@@ -50,7 +50,7 @@ def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
     grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
-    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
+    grid.add_row(Text(f"  klaude --resume {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 

klaude_code/tui/components/metadata.py

@@ -30,13 +30,12 @@ def _render_task_metadata_block(
     currency = metadata.usage.currency if metadata.usage else "USD"
     currency_symbol = "¥" if currency == "CNY" else "$"
 
-    # Second column: model@provider description / tokens / cost / …
+    # Second column: provider/model description / tokens / cost / …
     content = Text()
-    content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
     if metadata.provider is not None:
-        content.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
-            Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
-        )
+        content.append_text(Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA))
+        content.append_text(Text("/", style=ThemeKey.METADATA_DIM))
+    content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA_BOLD))
     if metadata.description:
         content.append_text(Text(" ", style=ThemeKey.METADATA)).append_text(
             Text(metadata.description, style=ThemeKey.METADATA_ITALIC)

klaude_code/tui/components/rich/markdown.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import io
+import re
 import time
 from collections.abc import Callable
 from typing import Any, ClassVar
@@ -26,6 +27,63 @@ from klaude_code.const import (
 )
 from klaude_code.tui.components.rich.code_panel import CodePanel
 
+_THINKING_HTML_BLOCK_RE = re.compile(
+    r"\A\s*<thinking>\s*\n?(?P<body>.*?)(?:\n\s*)?</thinking>\s*\Z",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+_HTML_COMMENT_BLOCK_RE = re.compile(r"\A\s*<!--.*?-->\s*\Z", flags=re.DOTALL)
+
+
+class ThinkingHTMLBlock(MarkdownElement):
+    """Render `<thinking>...</thinking>` HTML blocks as Rich Markdown.
+
+    markdown-it-py treats custom tags like `<thinking>` as HTML blocks, and Rich
+    Markdown ignores HTML blocks by default. This element restores visibility by
+    re-parsing the inner content as Markdown and applying a dedicated style.
+
+    Non-thinking HTML blocks (including comment sentinels like `<!-- -->`) render
+    no visible output, matching Rich's default behavior.
+    """
+
+    new_line: ClassVar[bool] = True
+
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> ThinkingHTMLBlock:
+        return cls(content=token.content or "", code_theme=markdown.code_theme)
+
+    def __init__(self, *, content: str, code_theme: str) -> None:
+        self._content = content
+        self._code_theme = code_theme
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        stripped = self._content.strip()
+
+        # Keep HTML comments invisible. MarkdownStream relies on a comment sentinel
+        # (`<!-- -->`) to preserve inter-block spacing in some streaming frames.
+        if _HTML_COMMENT_BLOCK_RE.match(stripped):
+            return
+
+        match = _THINKING_HTML_BLOCK_RE.match(stripped)
+        if match is None:
+            return
+
+        body = match.group("body").strip("\n")
+        if not body.strip():
+            return
+
+        # Render as a single line to avoid the extra blank lines produced by
+        # paragraph/block rendering.
+        collapsed = " ".join(body.split())
+        if not collapsed:
+            return
+
+        text = Text()
+        text.append("<thinking>", style="markdown.thinking.tag")
+        text.append(collapsed, style="markdown.thinking")
+        text.append("</thinking>", style="markdown.thinking.tag")
+        yield text
+
 
 class NoInsetCodeBlock(CodeBlock):
     """A code block with syntax highlighting and no padding."""
@@ -105,6 +163,7 @@ class NoInsetMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
     }
 
 
@@ -118,6 +177,7 @@ class ThinkingMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
     }
 
 

klaude_code/tui/components/rich/theme.py

@@ -331,7 +331,14 @@ def get_theme(theme: str | None = None) -> Themes:
         markdown_theme=Theme(
             styles={
                 "markdown.code": palette.purple,
+                # Render degraded `<thinking>...</thinking>` blocks inside assistant markdown.
+                # This must live in markdown_theme (not just thinking_markdown_theme) because
+                # it is used while rendering assistant output.
+                "markdown.thinking": "italic " + palette.grey2,
+                "markdown.thinking.tag": palette.grey2,
                 "markdown.code.border": palette.grey3,
+                # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
+                "markdown.code.block": palette.grey1,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2": "bold underline",
@@ -353,6 +360,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code": palette.grey1 + " italic on " + palette.code_background,
                 "markdown.code.block": palette.grey1,
                 "markdown.code.border": palette.grey3,
+                "markdown.thinking.tag": palette.grey2 + " dim",
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h3": "bold " + palette.grey1,

klaude_code/tui/components/sub_agent.py

@@ -135,6 +135,7 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
     description = profile.name
     prompt = ""
     output_schema: dict[str, Any] | None = None
+    generation: dict[str, Any] | None = None
     resume: str | None = None
     if e.arguments:
         try:
@@ -155,10 +156,15 @@ def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAg
             schema_value = payload.get(profile.output_schema_arg)
             if isinstance(schema_value, dict):
                 output_schema = cast(dict[str, Any], schema_value)
+        # Extract generation config for ImageGen
+        generation_value = payload.get("generation")
+        if isinstance(generation_value, dict):
+            generation = cast(dict[str, Any], generation_value)
     return model.SubAgentState(
         sub_agent_type=profile.name,
         sub_agent_desc=description,
         sub_agent_prompt=prompt,
         resume=resume,
         output_schema=output_schema,
+        generation=generation,
     )