klaude-code 1.8.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

klaude_code/cli/list_model.py

@@ -1,7 +1,7 @@
 import datetime
 
+from rich.box import HORIZONTALS
 from rich.console import Console, Group
-from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
@@ -9,65 +9,127 @@ from klaude_code.config import Config
 from klaude_code.config.config import ModelConfig, ProviderConfig, parse_env_var_syntax
 from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
+from klaude_code.ui.rich.quote import Quote
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
+from klaude_code.ui.utils.common import format_model_params
 
 
-def _get_codex_status_elements() -> list[Text]:
-    """Get Codex OAuth login status as Text elements for panel display."""
+def _get_codex_status_rows() -> list[tuple[Text, Text]]:
+    """Get Codex OAuth login status as (label, value) tuples for table display."""
     from klaude_code.auth.codex.token_manager import CodexTokenManager
 
-    elements: list[Text] = []
+    rows: list[tuple[Text, Text]] = []
     token_manager = CodexTokenManager()
     state = token_manager.get_state()
 
     if state is None:
-        elements.append(
-            Text.assemble(
-                ("Status: ", "bold"),
-                ("Not logged in", ThemeKey.CONFIG_STATUS_ERROR),
-                (" (run 'klaude login codex' to authenticate)", "dim"),
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Not logged in", ThemeKey.CONFIG_STATUS_ERROR),
+                    (" (run 'klaude login codex' to authenticate)", "dim"),
+                ),
             )
         )
     elif state.is_expired():
-        elements.append(
-            Text.assemble(
-                ("Status: ", "bold"),
-                ("Token expired", ThemeKey.CONFIG_STATUS_ERROR),
-                (" (run 'klaude login codex' to re-authenticate)", "dim"),
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Token expired", ThemeKey.CONFIG_STATUS_ERROR),
+                    (" (run 'klaude login codex' to re-authenticate)", "dim"),
+                ),
             )
         )
     else:
         expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
-        elements.append(
-            Text.assemble(
-                ("Status: ", "bold"),
-                ("Logged in", ThemeKey.CONFIG_STATUS_OK),
-                (f" (account: {state.account_id[:8]}..., expires: {expires_dt.strftime('%Y-%m-%d %H:%M UTC')})", "dim"),
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Logged in", ThemeKey.CONFIG_STATUS_OK),
+                    (
+                        f" (account: {state.account_id[:8]}…, expires: {expires_dt.strftime('%Y-%m-%d %H:%M UTC')})",
+                        "dim",
+                    ),
+                ),
             )
         )
 
-    elements.append(
-        Text.assemble(
-            ("Visit ", "dim"),
-            (
+    rows.append(
+        (
+            Text("Usage", style="dim"),
+            Text(
                 "https://chatgpt.com/codex/settings/usage",
-                "blue underline link https://chatgpt.com/codex/settings/usage",
+                style="blue link https://chatgpt.com/codex/settings/usage",
             ),
-            (" for up-to-date information on rate limits and credits", "dim"),
         )
     )
-    return elements
+    return rows
+
+
+def _get_claude_status_rows() -> list[tuple[Text, Text]]:
+    """Get Claude OAuth login status as (label, value) tuples for table display."""
+    from klaude_code.auth.claude.token_manager import ClaudeTokenManager
+
+    rows: list[tuple[Text, Text]] = []
+    token_manager = ClaudeTokenManager()
+    state = token_manager.get_state()
+
+    if state is None:
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Not logged in", ThemeKey.CONFIG_STATUS_ERROR),
+                    (" (run 'klaude login claude' to authenticate)", "dim"),
+                ),
+            )
+        )
+    elif state.is_expired():
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Token expired", ThemeKey.CONFIG_STATUS_ERROR),
+                    (" (will refresh automatically on use; run 'klaude login claude' if refresh fails)", "dim"),
+                ),
+            )
+        )
+    else:
+        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
+        rows.append(
+            (
+                Text("Status", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text.assemble(
+                    ("Logged in", ThemeKey.CONFIG_STATUS_OK),
+                    (f" (expires: {expires_dt.strftime('%Y-%m-%d %H:%M UTC')})", "dim"),
+                ),
+            )
+        )
+
+    rows.append(
+        (
+            Text("Usage", style="dim"),
+            Text(
+                "https://claude.ai/settings/usage",
+                style="blue link https://claude.ai/settings/usage",
+            ),
+        )
+    )
+    return rows
 
 
 def mask_api_key(api_key: str | None) -> str:
     """Mask API key to show only first 6 and last 6 characters with *** in between"""
-    if not api_key or api_key == "N/A":
-        return "N/A"
+    if not api_key:
+        return ""
 
     if len(api_key) <= 12:
         return api_key
 
-    return f"{api_key[:6]} … {api_key[-6:]}"
+    return f"{api_key[:6]}…{api_key[-6:]}"
 
 
 def format_api_key_display(provider: ProviderConfig) -> Text:
@@ -91,7 +153,7 @@ def format_api_key_display(provider: ProviderConfig) -> Text:
         # Plain API key
         return Text(mask_api_key(provider.api_key))
     else:
-        return Text("N/A")
+        return Text("")
 
 
 def format_env_var_display(value: str | None) -> Text:
@@ -114,194 +176,180 @@ def format_env_var_display(value: str | None) -> Text:
         # Plain value
         return Text(mask_api_key(value))
     else:
-        return Text("N/A")
+        return Text("")
 
 
 def _get_model_params_display(model: ModelConfig) -> list[Text]:
     """Get display elements for model parameters."""
-    params: list[Text] = []
-    if model.model_params.thinking:
-        if model.model_params.thinking.reasoning_effort is not None:
-            params.append(
-                Text.assemble(
-                    ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
-                    ": ",
-                    model.model_params.thinking.reasoning_effort,
-                )
-            )
-        if model.model_params.thinking.reasoning_summary is not None:
-            params.append(
-                Text.assemble(
-                    ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
-                    ": ",
-                    model.model_params.thinking.reasoning_summary,
-                )
-            )
-        if model.model_params.thinking.budget_tokens is not None:
-            params.append(
-                Text.assemble(
-                    ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
-                    ": ",
-                    str(model.model_params.thinking.budget_tokens),
-                )
-            )
-    if model.model_params.provider_routing:
-        params.append(
-            Text.assemble(
-                ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
-                ": ",
-                model.model_params.provider_routing.model_dump_json(exclude_none=True),
-            )
+    param_strings = format_model_params(model.model_params)
+    if param_strings:
+        return [Text(s) for s in param_strings]
+    return [Text("")]
+
+
+def _build_provider_info_panel(provider: ProviderConfig, available: bool) -> Quote:
+    """Build a Quote containing provider name and information using a two-column grid."""
+    # Provider name as title
+    if available:
+        title = Text(provider.provider_name, style=ThemeKey.CONFIG_PROVIDER)
+    else:
+        title = Text.assemble(
+            (provider.provider_name, ThemeKey.CONFIG_PROVIDER),
+            (" (Unavailable)", ThemeKey.CONFIG_STATUS_ERROR),
         )
-    if len(params) == 0:
-        params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
-    return params
 
+    # Build info table with two columns
+    info_table = Table.grid(padding=(0, 2))
+    info_table.add_column("Label", style=ThemeKey.CONFIG_PARAM_LABEL)
+    info_table.add_column("Value")
+
+    # Protocol
+    info_table.add_row(Text("Protocol"), Text(provider.protocol.value))
+
+    # Base URL (if set)
+    if provider.base_url:
+        info_table.add_row(Text("Base URL"), Text(provider.base_url))
+
+    # API key (if set)
+    if provider.api_key:
+        info_table.add_row(Text("API key"), format_api_key_display(provider))
+
+    # AWS Bedrock parameters
+    if provider.protocol == LLMClientProtocol.BEDROCK:
+        if provider.aws_access_key:
+            info_table.add_row(Text("AWS key"), format_env_var_display(provider.aws_access_key))
+        if provider.aws_secret_key:
+            info_table.add_row(Text("AWS secret"), format_env_var_display(provider.aws_secret_key))
+        if provider.aws_region:
+            info_table.add_row(Text("AWS region"), format_env_var_display(provider.aws_region))
+        if provider.aws_session_token:
+            info_table.add_row(Text("AWS token"), format_env_var_display(provider.aws_session_token))
+        if provider.aws_profile:
+            info_table.add_row(Text("AWS profile"), format_env_var_display(provider.aws_profile))
+
+    # OAuth status rows
+    if provider.protocol == LLMClientProtocol.CODEX_OAUTH:
+        for label, value in _get_codex_status_rows():
+            info_table.add_row(label, value)
+    if provider.protocol == LLMClientProtocol.CLAUDE_OAUTH:
+        for label, value in _get_claude_status_rows():
+            info_table.add_row(label, value)
+
+    return Quote(
+        Group(title, info_table),
+        style=ThemeKey.LINES,
+        prefix="┃ ",
+    )
 
-def display_models_and_providers(config: Config):
-    """Display models and providers configuration using rich formatting"""
-    themes = get_theme(config.theme)
-    console = Console(theme=themes.app_theme)
 
-    # Display each provider as a separate panel
-    for provider in config.provider_list:
-        # Provider info section
-        provider_info = Table.grid(padding=(0, 1))
-        provider_info.add_column(width=12)
-        provider_info.add_column()
+def _build_models_table(
+    provider: ProviderConfig, main_model: str | None, sub_agent_models: dict[str, str] | None = None
+) -> Table:
+    """Build a table for models under a provider."""
+    provider_available = not provider.is_api_key_missing()
 
-        provider_info.add_row(
-            Text("Protocol:", style=ThemeKey.CONFIG_PARAM_LABEL),
-            Text(provider.protocol.value),
-        )
-        if provider.base_url:
-            provider_info.add_row(
-                Text("Base URL:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                Text(provider.base_url or "N/A"),
-            )
-        if provider.api_key:
-            provider_info.add_row(
-                Text("API Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                format_api_key_display(provider),
-            )
+    # Build reverse mapping: model_name -> list of agent roles using it
+    model_to_agents: dict[str, list[str]] = {}
+    if sub_agent_models:
+        for agent_role, model_name in sub_agent_models.items():
+            if model_name not in model_to_agents:
+                model_to_agents[model_name] = []
+            model_to_agents[model_name].append(agent_role)
 
-        # AWS Bedrock parameters
-        if provider.protocol == LLMClientProtocol.BEDROCK:
-            if provider.aws_access_key:
-                provider_info.add_row(
-                    Text("AWS Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                    format_env_var_display(provider.aws_access_key),
-                )
-            if provider.aws_secret_key:
-                provider_info.add_row(
-                    Text("AWS Secret:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                    format_env_var_display(provider.aws_secret_key),
-                )
-            if provider.aws_region:
-                provider_info.add_row(
-                    Text("AWS Region:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                    format_env_var_display(provider.aws_region),
-                )
-            if provider.aws_session_token:
-                provider_info.add_row(
-                    Text("AWS Token:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                    format_env_var_display(provider.aws_session_token),
-                )
-            if provider.aws_profile:
-                provider_info.add_row(
-                    Text("AWS Profile:", style=ThemeKey.CONFIG_PARAM_LABEL),
-                    format_env_var_display(provider.aws_profile),
+    models_table = Table.grid(
+        padding=(0, 2),
+    )
+    models_table.add_column("Model Name", min_width=12)
+    models_table.add_column("Model ID", min_width=20, style=ThemeKey.CONFIG_MODEL_ID)
+    models_table.add_column("Params", style="dim")
+
+    model_count = len(provider.model_list)
+    for i, model in enumerate(provider.model_list):
+        is_last = i == model_count - 1
+        prefix = " └─ " if is_last else " ├─ "
+
+        if not provider_available:
+            name = Text.assemble((prefix, ThemeKey.LINES), (model.model_name, "dim"))
+            model_id = Text(model.model_params.model or "", style="dim")
+            params = Text("(unavailable)", style="dim")
+        else:
+            # Build role tags for this model
+            roles: list[str] = []
+            if model.model_name == main_model:
+                roles.append("default")
+            if model.model_name in model_to_agents:
+                roles.extend(role.lower() for role in model_to_agents[model.model_name])
+
+            if roles:
+                name = Text.assemble(
+                    (prefix, ThemeKey.LINES),
+                    (model.model_name, ThemeKey.CONFIG_STATUS_PRIMARY),
+                    (f" ({', '.join(roles)})", "dim"),
                 )
+            else:
+                name = Text.assemble((prefix, ThemeKey.LINES), (model.model_name, ThemeKey.CONFIG_ITEM_NAME))
+            model_id = Text(model.model_params.model or "")
+            params = Text(" · ").join(_get_model_params_display(model))
 
-        # Check if provider has valid API key
-        provider_available = not provider.is_api_key_missing()
+        models_table.add_row(name, model_id, params)
 
-        # Models table for this provider
-        models_table = Table.grid(padding=(0, 1), expand=True)
-        models_table.add_column(width=2, no_wrap=True)  # Status
-        models_table.add_column(overflow="fold", ratio=2)  # Name
-        models_table.add_column(overflow="fold", ratio=3)  # Model
-        models_table.add_column(overflow="fold", ratio=4)  # Params
-
-        # Add header
-        models_table.add_row(
-            Text("", style="bold"),
-            Text("Name", style=ThemeKey.CONFIG_TABLE_HEADER),
-            Text("Model", style=ThemeKey.CONFIG_TABLE_HEADER),
-            Text("Params", style=ThemeKey.CONFIG_TABLE_HEADER),
-        )
+    return models_table
 
-        # Add models for this provider
-        for model in provider.model_list:
-            if not provider_available:
-                # Provider API key not set - show as unavailable
-                status = Text("-", style="dim")
-                name = Text(model.model_name, style="dim")
-                model_id = Text(model.model_params.model or "N/A", style="dim")
-                params = [Text("(unavailable)", style="dim")]
-            elif model.model_name == config.main_model:
-                status = Text("★", style=ThemeKey.CONFIG_STATUS_PRIMARY)
-                name = Text(model.model_name, style=ThemeKey.CONFIG_STATUS_PRIMARY)
-                model_id = Text(model.model_params.model or "N/A", style="")
-                params = _get_model_params_display(model)
-            else:
-                status = Text("✔", style=ThemeKey.CONFIG_STATUS_OK)
-                name = Text(model.model_name, style=ThemeKey.CONFIG_ITEM_NAME)
-                model_id = Text(model.model_params.model or "N/A", style="")
-                params = _get_model_params_display(model)
-
-            models_table.add_row(status, name, model_id, Group(*params))
-
-        # Create panel content with provider info and models
-        panel_elements = [
-            provider_info,
-            Text(""),  # Spacer
-            Text("Models:", style=ThemeKey.CONFIG_TABLE_HEADER),
-            models_table,
-        ]
-
-        # Add Codex status if this is a codex provider
-        if provider.protocol == LLMClientProtocol.CODEX:
-            panel_elements.append(Text(""))  # Spacer
-            panel_elements.extend(_get_codex_status_elements())
-
-        panel_content = Group(*panel_elements)
-
-        panel = Panel(
-            panel_content,
-            title=Text(f"Provider: {provider.provider_name}", style=ThemeKey.CONFIG_PROVIDER),
-            border_style=ThemeKey.CONFIG_PANEL_BORDER,
-            padding=(0, 1),
-            title_align="left",
-        )
 
-        console.print(panel)
-        console.print()
+def _display_agent_models_table(config: Config, console: Console) -> None:
+    """Display model assignments as a table."""
+    console.print(Text(" Agent Models:", style=ThemeKey.CONFIG_TABLE_HEADER))
+    agent_table = Table(
+        box=HORIZONTALS,
+        show_header=True,
+        header_style=ThemeKey.CONFIG_TABLE_HEADER,
+        padding=(0, 2),
+        border_style=ThemeKey.LINES,
+    )
+    agent_table.add_column("Role", style="bold", min_width=10)
+    agent_table.add_column("Model", style=ThemeKey.CONFIG_STATUS_PRIMARY)
 
-    # Display main model info
-    console.print()
+    # Default model
     if config.main_model:
-        console.print(
-            Text.assemble(
-                ("Default Model: ", "bold"),
-                (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
-            )
-        )
+        agent_table.add_row("Default", config.main_model)
     else:
-        console.print(
-            Text.assemble(
-                ("Default Model: ", "bold"),
-                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
-            )
-        )
+        agent_table.add_row("Default", Text("(not set)", style=ThemeKey.CONFIG_STATUS_ERROR))
 
+    # Sub-agent models
     for profile in iter_sub_agent_profiles():
         sub_model_name = config.sub_agent_models.get(profile.name)
-        if not sub_model_name:
-            continue
-        console.print(
-            Text.assemble(
-                (f"{profile.name} Model: ", "bold"),
-                (sub_model_name, ThemeKey.CONFIG_STATUS_PRIMARY),
-            )
-        )
+        if sub_model_name:
+            agent_table.add_row(profile.name, sub_model_name)
+
+    console.print(agent_table)
+
+
+def display_models_and_providers(config: Config, *, show_all: bool = False):
+    """Display models and providers configuration using rich formatting"""
+    themes = get_theme(config.theme)
+    console = Console(theme=themes.app_theme)
+
+    # Display model assignments as a table
+    _display_agent_models_table(config, console)
+    console.print()
+
+    # Sort providers: available (api_key set) first, unavailable (api_key not set) last
+    sorted_providers = sorted(config.provider_list, key=lambda p: (p.is_api_key_missing(), p.provider_name))
+
+    # Filter out unavailable providers unless show_all is True
+    if not show_all:
+        sorted_providers = [p for p in sorted_providers if not p.is_api_key_missing()]
+
+    # Display each provider with its models table
+    for provider in sorted_providers:
+        provider_available = not provider.is_api_key_missing()
+
+        # Provider info panel
+        provider_panel = _build_provider_info_panel(provider, provider_available)
+        console.print(provider_panel)
+        console.print()
+
+        # Models table for this provider
+        models_table = _build_models_table(provider, config.main_model, config.sub_agent_models)
+        console.print(models_table)
+        console.print("\n")

klaude_code/cli/main.py

@@ -286,7 +286,7 @@ def main_callback(
             raise typer.Exit(2)
 
         # In non-interactive environments, default to exec-mode behavior.
-        # This allows: echo "..." | klaude
+        # This allows: echo "…" | klaude
         if not sys.stdin.isatty() or not sys.stdout.isatty():
             if continue_ or resume or resume_by_id is not None:
                 log(("Error: --continue/--resume options require a TTY", "red"))

klaude_code/cli/runtime.py

@@ -17,8 +17,8 @@ from klaude_code.core.agent import Agent, DefaultModelProfileProvider, VanillaMo
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
 from klaude_code.protocol import events, llm_param, op
-from klaude_code.protocol import model as protocol_model
-from klaude_code.protocol.model import UserInputPayload
+from klaude_code.protocol import message as protocol_message
+from klaude_code.protocol.message import UserInputPayload
 from klaude_code.session.session import Session, close_default_store
 from klaude_code.trace import DebugType, log, set_debug_logging
 from klaude_code.ui.modes.repl import build_repl_status_snapshot
@@ -105,9 +105,11 @@ async def submit_user_input_payload(
     if result.persist_user_input:
         agent.session.append_history(
             [
-                protocol_model.UserMessageItem(
-                    content=persisted_user_input.text,
-                    images=persisted_user_input.images,
+                protocol_message.UserMessage(
+                    parts=protocol_message.parts_from_text_and_images(
+                        persisted_user_input.text,
+                        persisted_user_input.images,
+                    )
                 )
             ]
         )

klaude_code/cli/self_update.py

@@ -228,7 +228,7 @@ def update_command(
         log(f"To update, install uv and run `uv tool upgrade {PACKAGE_NAME}`.")
         raise typer.Exit(1)
 
-    log(f"Running `uv tool upgrade {PACKAGE_NAME}`...")
+    log(f"Running `uv tool upgrade {PACKAGE_NAME}`…")
     result = subprocess.run(["uv", "tool", "upgrade", PACKAGE_NAME], check=False)
     if result.returncode != 0:
         log((f"Error: update failed (exit code {result.returncode}).", "red"))

klaude_code/cli/session_cmd.py

@@ -25,7 +25,7 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
         first_msg_text = s.user_messages[0] if s.user_messages else ""
         first_msg = first_msg_text.strip().replace("\n", " ")[:50]
         if len(first_msg_text) > 50:
-            first_msg += "..."
+            first_msg += "…"
         log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
 
     items: list[SelectItem[bool]] = [

klaude_code/command/clear_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, model, op
+from klaude_code.protocol import commands, message, op
 
 
 class ClearCommand(CommandABC):
@@ -13,8 +13,12 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         del user_input  # unused
+        import os
+
+        os.system("cls" if os.name == "nt" else "clear")
+
         return CommandResult(
             operations=[op.ClearSessionOperation(session_id=agent.session.id)],
             persist_user_input=False,

klaude_code/command/command_abc.py

@@ -4,7 +4,7 @@ from typing import Protocol
 from pydantic import BaseModel
 
 from klaude_code.llm import LLMClientABC
-from klaude_code.protocol import commands, llm_param, model, op
+from klaude_code.protocol import commands, llm_param, message, op
 from klaude_code.protocol import events as protocol_events
 from klaude_code.session.session import Session
 
@@ -78,7 +78,7 @@ class CommandABC(ABC):
         return "additional instructions"
 
     @abstractmethod
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         """
         Execute the command.
 

klaude_code/command/debug_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events, model
+from klaude_code.protocol import commands, events, message, model
 from klaude_code.trace import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
 
 
@@ -45,7 +45,7 @@ class DebugCommand(CommandABC):
     def placeholder(self) -> str:
         return "filter types"
 
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         raw = user_input.text.strip()
 
         # /debug (no args) - enable debug
@@ -70,8 +70,8 @@ class DebugCommand(CommandABC):
             events=[
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=content,
+                    item=message.DeveloperMessage(
+                        parts=message.text_parts_from_str(content),
                         command_output=model.CommandOutput(command_name=self.name),
                     ),
                 )

klaude_code/command/export_cmd.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, model, op
+from klaude_code.protocol import commands, message, op
 
 
 class ExportCommand(CommandABC):
@@ -29,7 +29,7 @@ class ExportCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         output_path = self._normalize_output_path(user_input.text, agent)
         return CommandResult(
             operations=[