klaude-code 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

klaude_code/tui/command/registry.py

@@ -2,7 +2,7 @@ from importlib.resources import files
 from typing import TYPE_CHECKING
 
 from klaude_code.log import log_debug
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 
 from .command_abc import Agent, CommandResult
 from .prompt_command import PromptCommand
@@ -179,30 +179,24 @@ async def dispatch_command(user_input: message.UserInputPayload, agent: Agent, *
             result.operations = ops
         return result
     except Exception as e:
-        command_output = (
-            model.CommandOutput(command_name=command_identifier, is_error=True)
-            if isinstance(command_identifier, commands.CommandName)
-            else None
-        )
-        ui_extra = (
-            model.build_command_output_extra(
-                command_output.command_name,
-                ui_extra=command_output.ui_extra,
-                is_error=command_output.is_error,
+        error_content = f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}"
+        if isinstance(command_identifier, commands.CommandName):
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=command_identifier,
+                        content=error_content,
+                        is_error=True,
+                    )
+                ]
             )
-            if command_output is not None
-            else None
-        )
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.ErrorEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(
-                            f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}"
-                        ),
-                        ui_extra=ui_extra,
-                    ),
+                    error_message=error_content,
+                    can_retry=False,
                 )
             ]
         )

klaude_code/tui/command/resume_cmd.py

@@ -3,7 +3,7 @@ import asyncio
 from prompt_toolkit.styles import Style
 
 from klaude_code.log import log
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.tui.terminal.selector import SelectItem, select_one
 
@@ -87,29 +87,23 @@ class ResumeCommand(CommandABC):
         del user_input  # unused
 
         if agent.session.messages_count > 0:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(
-                        "Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection."
-                    ),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                is_error=True,
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(no session selected)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(no session selected)",
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         return CommandResult(
             operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
-            persist=False,
         )

klaude_code/tui/command/status_cmd.py

@@ -138,19 +138,15 @@ class StatusCommand(CommandABC):
         session = agent.session
         aggregated = accumulate_session_usage(session)
 
-        event = events.DeveloperMessageEvent(
+        event = events.CommandOutputEvent(
             session_id=session.id,
-            item=message.DeveloperMessage(
-                parts=message.text_parts_from_str(format_status_content(aggregated)),
-                ui_extra=model.build_command_output_extra(
-                    self.name,
-                    ui_extra=model.SessionStatusUIExtra(
-                        usage=aggregated.total,
-                        task_count=aggregated.task_count,
-                        by_model=aggregated.by_model,
-                    ),
-                ),
+            command_name=self.name,
+            content=format_status_content(aggregated),
+            ui_extra=model.SessionStatusUIExtra(
+                usage=aggregated.total,
+                task_count=aggregated.task_count,
+                by_model=aggregated.by_model,
             ),
         )
 
-        return CommandResult(events=[event], persist=False)
+        return CommandResult(events=[event])

klaude_code/tui/command/sub_agent_model_cmd.py

@@ -0,0 +1,185 @@
+"""Command for changing sub-agent models."""
+
+from __future__ import annotations
+
+import asyncio
+
+from prompt_toolkit.styles import Style
+
+from klaude_code.config.config import load_config
+from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper, SubAgentModelInfo
+from klaude_code.protocol import commands, events, message, op
+from klaude_code.tui.terminal.selector import SelectItem, build_model_select_items, select_one
+
+from .command_abc import Agent, CommandABC, CommandResult
+
+SELECT_STYLE = Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
+        ("text", "ansibrightblack"),
+        ("question", "bold"),
+        ("meta", "fg:ansibrightblack"),
+        ("msg", ""),
+    ]
+)
+
+USE_DEFAULT_BEHAVIOR = "__default__"
+
+
+def _build_sub_agent_select_items(
+    sub_agents: list[SubAgentModelInfo],
+    helper: SubAgentModelHelper,
+    main_model_name: str,
+) -> list[SelectItem[str]]:
+    """Build SelectItem list for sub-agent selection."""
+    items: list[SelectItem[str]] = []
+    max_name_len = max(len(sa.profile.name) for sa in sub_agents) if sub_agents else 0
+
+    for sa in sub_agents:
+        name = sa.profile.name
+
+        if sa.configured_model:
+            model_display = sa.configured_model
+        else:
+            behavior = helper.describe_empty_model_config_behavior(name, main_model_name=main_model_name)
+            model_display = f"({behavior.description})"
+
+        title = [
+            ("class:msg", f"{name:<{max_name_len}}"),
+            ("class:meta", f"  current: {model_display}\n"),
+        ]
+        items.append(SelectItem(title=title, value=name, search_text=name))
+
+    return items
+
+
+def _select_sub_agent_sync(
+    sub_agents: list[SubAgentModelInfo],
+    helper: SubAgentModelHelper,
+    main_model_name: str,
+) -> str | None:
+    """Synchronous sub-agent type selection."""
+    items = _build_sub_agent_select_items(sub_agents, helper, main_model_name)
+    if not items:
+        return None
+
+    try:
+        result = select_one(
+            message="Select sub-agent to configure:",
+            items=items,
+            pointer="->",
+            style=SELECT_STYLE,
+            use_search_filter=False,
+        )
+        return result if isinstance(result, str) else None
+    except KeyboardInterrupt:
+        return None
+
+
+def _select_model_for_sub_agent_sync(
+    helper: SubAgentModelHelper,
+    sub_agent_type: str,
+    main_model_name: str,
+) -> str | None:
+    """Synchronous model selection for a sub-agent."""
+    models = helper.get_selectable_models(sub_agent_type)
+
+    default_behavior = helper.describe_empty_model_config_behavior(sub_agent_type, main_model_name=main_model_name)
+
+    inherit_item = SelectItem[str](
+        title=[
+            ("class:msg", "(Use default behavior)"),
+            ("class:meta", f"  -> {default_behavior.description}\n"),
+        ],
+        value=USE_DEFAULT_BEHAVIOR,
+        search_text="default unset",
+    )
+    model_items = build_model_select_items(models)
+    all_items = [inherit_item, *model_items]
+
+    try:
+        result = select_one(
+            message=f"Select model for {sub_agent_type}:",
+            items=all_items,
+            pointer="->",
+            style=SELECT_STYLE,
+            use_search_filter=True,
+        )
+        return result if isinstance(result, str) else None
+    except KeyboardInterrupt:
+        return None
+
+
+class SubAgentModelCommand(CommandABC):
+    """Configure models for sub-agents (Task, Explore, WebAgent, ImageGen)."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.SUB_AGENT_MODEL
+
+    @property
+    def summary(self) -> str:
+        return "Change sub-agent models"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        config = load_config()
+        helper = SubAgentModelHelper(config)
+        main_model_name = agent.get_llm_client().model_name
+
+        sub_agents = helper.get_available_sub_agents()
+        if not sub_agents:
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=self.name,
+                        content="No sub-agents available",
+                        is_error=True,
+                    )
+                ]
+            )
+
+        selected_sub_agent = await asyncio.to_thread(_select_sub_agent_sync, sub_agents, helper, main_model_name)
+        if selected_sub_agent is None:
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=self.name,
+                        content="(cancelled)",
+                    )
+                ]
+            )
+
+        selected_model = await asyncio.to_thread(
+            _select_model_for_sub_agent_sync, helper, selected_sub_agent, main_model_name
+        )
+        if selected_model is None:
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=self.name,
+                        content="(cancelled)",
+                    )
+                ]
+            )
+
+        model_name: str | None = None if selected_model == USE_DEFAULT_BEHAVIOR else selected_model
+
+        return CommandResult(
+            operations=[
+                op.ChangeSubAgentModelOperation(
+                    session_id=agent.session.id,
+                    sub_agent_type=selected_sub_agent,
+                    model_name=model_name,
+                    save_as_default=True,
+                )
+            ]
+        )

klaude_code/tui/command/terminal_setup_cmd.py

@@ -2,7 +2,7 @@ import os
 import subprocess
 from pathlib import Path
 
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 
 from .command_abc import Agent, CommandABC, CommandResult
 
@@ -226,12 +226,10 @@ class TerminalSetupCommand(CommandABC):
         """Create success result"""
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(msg),
-                        ui_extra=model.build_command_output_extra(self.name),
-                    ),
+                    command_name=self.name,
+                    content=msg,
                 )
             ]
         )
@@ -240,12 +238,11 @@ class TerminalSetupCommand(CommandABC):
         """Create error result"""
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(msg),
-                        ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                    ),
+                    command_name=self.name,
+                    content=msg,
+                    is_error=True,
                 )
             ]
         )

klaude_code/tui/command/thinking_cmd.py

@@ -3,7 +3,7 @@ import asyncio
 from prompt_toolkit.styles import Style
 
 from klaude_code.config.thinking import get_thinking_picker_data, parse_thinking_value
-from klaude_code.protocol import commands, events, llm_param, message, model, op
+from klaude_code.protocol import commands, events, llm_param, message, op
 from klaude_code.tui.terminal.selector import SelectItem, select_one
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -79,12 +79,10 @@ class ThinkingCommand(CommandABC):
         if new_thinking is None:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("(no change)"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="(no change)",
                     )
                 ]
             )

klaude_code/tui/commands.py

@@ -38,6 +38,11 @@ class RenderDeveloperMessage(RenderCommand):
     event: events.DeveloperMessageEvent
 
 
+@dataclass(frozen=True, slots=True)
+class RenderCommandOutput(RenderCommand):
+    event: events.CommandOutputEvent
+
+
 @dataclass(frozen=True, slots=True)
 class RenderTurnStart(RenderCommand):
     event: events.TurnStartEvent

klaude_code/tui/components/bash_syntax.py

@@ -3,7 +3,7 @@
 import re
 from typing import Any
 
-from pygments.lexers import BashLexer  # pyright: ignore[reportUnknownVariableType]
+from pygments.lexers.shell import BashLexer  # pyright: ignore[reportMissingTypeStubs, reportUnknownVariableType]
 from pygments.token import Token
 from rich.text import Text
 

klaude_code/tui/components/command_output.py

@@ -0,0 +1,96 @@
+from rich.console import RenderableType
+from rich.padding import Padding
+from rich.table import Table
+from rich.text import Text
+
+from klaude_code.protocol import events, model
+from klaude_code.tui.components.common import truncate_middle
+from klaude_code.tui.components.rich.theme import ThemeKey
+
+
+def render_command_output(e: events.CommandOutputEvent) -> RenderableType:
+    """Render command output content."""
+    match e.command_name:
+        case "status":
+            return _render_status_output(e)
+        case "fork-session":
+            return _render_fork_session_output(e)
+        case _:
+            content = e.content or "(no content)"
+            style = ThemeKey.TOOL_RESULT if not e.is_error else ThemeKey.ERROR
+            return Padding.indent(truncate_middle(content, base_style=style), level=2)
+
+
+def _format_tokens(tokens: int) -> str:
+    """Format token count with K/M suffix for readability."""
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.2f}M"
+    if tokens >= 1_000:
+        return f"{tokens / 1_000:.1f}K"
+    return str(tokens)
+
+
+def _format_cost(cost: float | None, currency: str = "USD") -> str:
+    """Format cost with currency symbol."""
+    if cost is None:
+        return "-"
+    symbol = "Y" if currency == "CNY" else "$"
+    if cost < 0.01:
+        return f"{symbol}{cost:.4f}"
+    return f"{symbol}{cost:.2f}"
+
+
+def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
+    """Render fork session output with usage instructions."""
+    if not isinstance(e.ui_extra, model.SessionIdUIExtra):
+        return Padding.indent(Text(e.content, style=ThemeKey.TOOL_RESULT), level=2)
+
+    grid = Table.grid(padding=(0, 1))
+    session_id = e.ui_extra.session_id
+    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))
+
+    return Padding.indent(grid, level=2)
+
+
+def _render_status_output(e: events.CommandOutputEvent) -> RenderableType:
+    """Render session status with total cost and per-model breakdown."""
+    if not isinstance(e.ui_extra, model.SessionStatusUIExtra):
+        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
+
+    status = e.ui_extra
+    usage = status.usage
+
+    table = Table.grid(padding=(0, 2))
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
+
+    # Total cost line
+    table.add_row(
+        Text("Total cost:", style=ThemeKey.TOOL_RESULT_BOLD),
+        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.TOOL_RESULT_BOLD),
+    )
+
+    # Per-model breakdown
+    if status.by_model:
+        table.add_row(Text("Usage by model:", style=ThemeKey.TOOL_RESULT_BOLD), "")
+        for meta in status.by_model:
+            model_label = meta.model_name
+            if meta.provider:
+                model_label = f"{meta.model_name} ({meta.provider.lower().replace(' ', '-')})"
+
+            if meta.usage:
+                usage_detail = (
+                    f"{_format_tokens(meta.usage.input_tokens)} input, "
+                    f"{_format_tokens(meta.usage.output_tokens)} output, "
+                    f"{_format_tokens(meta.usage.cached_tokens)} cache read, "
+                    f"{_format_tokens(meta.usage.reasoning_tokens)} thinking, "
+                    f"({_format_cost(meta.usage.total_cost, meta.usage.currency)})"
+                )
+            else:
+                usage_detail = "(no usage data)"
+            table.add_row(f"{model_label}:", usage_detail)
+
+    return Padding.indent(table, level=2)

klaude_code/tui/components/common.py

@@ -106,7 +106,7 @@ def truncate_head(
     text = text.expandtabs(TAB_EXPAND_WIDTH)
     lines = [line for line in text.split("\n") if line.strip()]
 
-    out = Text()
+    out = Text(overflow="fold")
     if base_style is not None:
         out.style = base_style
 

klaude_code/tui/components/developer.py

@@ -1,30 +1,18 @@
 from rich.console import Group, RenderableType
-from rich.padding import Padding
-from rich.table import Table
 from rich.text import Text
 
-from klaude_code.protocol import commands, events, message, model
-from klaude_code.tui.components.common import create_grid, truncate_middle
-from klaude_code.tui.components.rich.markdown import NoInsetMarkdown
+from klaude_code.protocol import events, model
+from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.tui.components.tools import render_path
 
 REMINDER_BULLET = "  ⧉"
 
 
-def get_command_output(item: message.DeveloperMessage) -> model.CommandOutput | None:
-    if not item.ui_extra:
-        return None
-    for ui_item in item.ui_extra.items:
-        if isinstance(ui_item, model.CommandOutputUIItem):
-            return ui_item.output
-    return None
-
-
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
     if not e.item.ui_extra:
         return False
-    return any(not isinstance(ui_item, model.CommandOutputUIItem) for ui_item in e.item.ui_extra.items)
+    return len(e.item.ui_extra.items) > 0
 
 
 def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
@@ -127,105 +115,5 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
                         ),
                     )
                     parts.append(grid)
-                case model.CommandOutputUIItem():
-                    # Rendered via render_command_output
-                    pass
 
     return Group(*parts) if parts else Text("")
-
-
-def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
-    """Render developer command output content."""
-    command_output = get_command_output(e.item)
-    if not command_output:
-        return Text("")
-
-    content = message.join_text_parts(e.item.parts)
-    match command_output.command_name:
-        case commands.CommandName.HELP:
-            return Padding.indent(Text.from_markup(content or "", style=ThemeKey.TOOL_RESULT), level=2)
-        case commands.CommandName.STATUS:
-            return _render_status_output(command_output)
-        case commands.CommandName.RELEASE_NOTES:
-            return Padding.indent(NoInsetMarkdown(content or ""), level=2)
-        case commands.CommandName.FORK_SESSION:
-            return _render_fork_session_output(command_output)
-        case _:
-            content = content or "(no content)"
-            style = ThemeKey.TOOL_RESULT if not command_output.is_error else ThemeKey.ERROR
-            return Padding.indent(truncate_middle(content, base_style=style), level=2)
-
-
-def _format_tokens(tokens: int) -> str:
-    """Format token count with K/M suffix for readability."""
-    if tokens >= 1_000_000:
-        return f"{tokens / 1_000_000:.2f}M"
-    if tokens >= 1_000:
-        return f"{tokens / 1_000:.1f}K"
-    return str(tokens)
-
-
-def _format_cost(cost: float | None, currency: str = "USD") -> str:
-    """Format cost with currency symbol."""
-    if cost is None:
-        return "-"
-    symbol = "¥" if currency == "CNY" else "$"
-    if cost < 0.01:
-        return f"{symbol}{cost:.4f}"
-    return f"{symbol}{cost:.2f}"
-
-
-def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
-    """Render fork session output with usage instructions."""
-    if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
-        return Padding.indent(Text("(no session id)", style=ThemeKey.TOOL_RESULT), level=2)
-
-    grid = Table.grid(padding=(0, 1))
-    session_id = command_output.ui_extra.session_id
-    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))
-
-    return Padding.indent(grid, level=2)
-
-
-def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
-    """Render session status with total cost and per-model breakdown."""
-    if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):
-        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
-
-    status = command_output.ui_extra
-    usage = status.usage
-
-    table = Table.grid(padding=(0, 2))
-    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
-    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
-
-    # Total cost line
-    table.add_row(
-        Text("Total cost:", style=ThemeKey.TOOL_RESULT_BOLD),
-        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.TOOL_RESULT_BOLD),
-    )
-
-    # Per-model breakdown
-    if status.by_model:
-        table.add_row(Text("Usage by model:", style=ThemeKey.TOOL_RESULT_BOLD), "")
-        for meta in status.by_model:
-            model_label = meta.model_name
-            if meta.provider:
-                model_label = f"{meta.model_name} ({meta.provider.lower().replace(' ', '-')})"
-
-            if meta.usage:
-                usage_detail = (
-                    f"{_format_tokens(meta.usage.input_tokens)} input, "
-                    f"{_format_tokens(meta.usage.output_tokens)} output, "
-                    f"{_format_tokens(meta.usage.cached_tokens)} cache read, "
-                    f"{_format_tokens(meta.usage.reasoning_tokens)} thinking, "
-                    f"({_format_cost(meta.usage.total_cost, meta.usage.currency)})"
-                )
-            else:
-                usage_detail = "(no usage data)"
-            table.add_row(f"{model_label}:", usage_detail)
-
-    return Padding.indent(table, level=2)