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

klaude_code/command/export_online_cmd.py

@@ -10,7 +10,7 @@ from rich.console import Console
 from rich.text import Text
 
 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.session.export import build_export_html
 
 
@@ -33,15 +33,15 @@ class ExportOnlineCommand(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:
         del user_input  # unused
         # Check if npx or surge is available
         surge_cmd = self._get_surge_command()
         if not surge_cmd:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="surge.sh CLI not found. Install with: npm install -g surge",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str("surge.sh CLI not found. Install with: npm install -g surge"),
                     command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )
@@ -50,29 +50,29 @@ class ExportOnlineCommand(CommandABC):
         try:
             console = Console()
             # Check login status inside status context since npx surge whoami can be slow
-            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
+            with console.status(Text("Checking surge.sh login status…", style="dim"), spinner_style="dim"):
                 logged_in = self._is_surge_logged_in(surge_cmd)
 
             if not logged_in:
                 login_cmd = " ".join([*surge_cmd, "login"])
                 event = events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    item=message.DeveloperMessage(
+                        parts=message.text_parts_from_str(f"Not logged in to surge.sh. Please run: {login_cmd}"),
                         command_output=model.CommandOutput(command_name=self.name, is_error=True),
                     ),
                 )
                 return CommandResult(events=[event])
 
-            with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
+            with console.status(Text("Deploying to surge.sh…", style="dim"), spinner_style="dim"):
                 html_doc = self._build_html(agent)
                 domain = self._generate_domain()
                 url = self._deploy_to_surge(surge_cmd, html_doc, domain)
 
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Session deployed to: {url}",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str(f"Session deployed to: {url}"),
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
@@ -82,8 +82,8 @@ class ExportOnlineCommand(CommandABC):
 
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str(f"Failed to deploy session: {exc}\n{traceback.format_exc()}"),
                     command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )

klaude_code/command/fork_session_cmd.py

@@ -6,7 +6,7 @@ from typing import Literal
 from prompt_toolkit.styles import Style
 
 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.ui.modes.repl.clipboard import copy_to_clipboard
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
@@ -41,29 +41,29 @@ def _truncate(text: str, max_len: int = 60) -> str:
     text = text.replace("\n", " ").strip()
     if len(text) <= max_len:
         return text
-    return text[: max_len - 3] + "..."
+    return text[: max_len - 1] + "…"
 
 
-def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list[ForkPoint]:
     """Build list of fork points from conversation history.
 
     Fork points are:
-    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - Each UserMessage position (for UI display, including first which would be empty session)
     - The end of the conversation (fork entire conversation)
     """
     fork_points: list[ForkPoint] = []
     user_indices: list[int] = []
 
     for i, item in enumerate(conversation_history):
-        if isinstance(item, model.UserMessageItem):
+        if isinstance(item, message.UserMessage):
             user_indices.append(i)
 
-    # For each UserMessageItem, create a fork point at that position
+    # For each UserMessage, create a fork point at that position
     for i, user_idx in enumerate(user_indices):
         user_item = conversation_history[user_idx]
-        assert isinstance(user_item, model.UserMessageItem)
+        assert isinstance(user_item, message.UserMessage)
 
-        # Find the end of this "task" (next UserMessageItem or end of history)
+        # Find the end of this "task" (next UserMessage or end of history)
         next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
 
         # Count tool calls by name and find last assistant message in this segment
@@ -71,15 +71,19 @@ def _build_fork_points(conversation_history: list[model.ConversationItem]) -> li
         last_assistant_content = ""
         for j in range(user_idx, next_user_idx):
             item = conversation_history[j]
-            if isinstance(item, model.ToolCallItem):
-                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
-            elif isinstance(item, model.AssistantMessageItem) and item.content:
-                last_assistant_content = item.content
-
+            if isinstance(item, message.AssistantMessage):
+                for part in item.parts:
+                    if isinstance(part, message.ToolCallPart):
+                        tool_stats[part.tool_name] = tool_stats.get(part.tool_name, 0) + 1
+                text = message.join_text_parts(item.parts)
+                if text:
+                    last_assistant_content = text
+
+        user_text = message.join_text_parts(user_item.parts)
         fork_points.append(
             ForkPoint(
                 history_index=user_idx,
-                user_message=user_item.content or "(empty)",
+                user_message=user_text or "(empty)",
                 tool_call_stats=tool_stats,
                 last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
             )
@@ -195,14 +199,14 @@ class ForkSessionCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    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
 
         if agent.session.messages_count == 0:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="(no messages to fork)",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str("(no messages to fork)"),
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
@@ -221,8 +225,8 @@ class ForkSessionCommand(CommandABC):
 
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Session forked successfully. New session id: {new_session.id}",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str(f"Session forked successfully. New session id: {new_session.id}"),
                     command_output=model.CommandOutput(
                         command_name=self.name,
                         ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
@@ -237,8 +241,8 @@ class ForkSessionCommand(CommandABC):
         if selected == "cancelled":
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="(fork cancelled)",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str("(fork cancelled)"),
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )
@@ -256,8 +260,10 @@ class ForkSessionCommand(CommandABC):
 
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
-            item=model.DeveloperMessageItem(
-                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+            item=message.DeveloperMessage(
+                parts=message.text_parts_from_str(
+                    f"Session forked ({fork_description}). New session id: {new_session.id}"
+                ),
                 command_output=model.CommandOutput(
                     command_name=self.name,
                     ui_extra=model.SessionIdUIExtra(session_id=new_session.id),

klaude_code/command/help_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
 
 
 class HelpCommand(CommandABC):
@@ -13,7 +13,7 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    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
         lines: list[str] = [
             """
@@ -41,8 +41,8 @@ Available slash commands:"""
 
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
-            item=model.DeveloperMessageItem(
-                content="\n".join(lines),
+            item=message.DeveloperMessage(
+                parts=message.text_parts_from_str("\n".join(lines)),
                 command_output=model.CommandOutput(command_name=self.name),
             ),
         )

klaude_code/command/model_cmd.py

@@ -4,7 +4,7 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.command.model_select import select_model_interactive
-from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 SELECT_STYLE = Style(
@@ -65,7 +65,7 @@ class ModelCommand(CommandABC):
     def placeholder(self) -> str:
         return "model name"
 
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         selected_model = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None
@@ -74,8 +74,8 @@ class ModelCommand(CommandABC):
                 events=[
                     events.DeveloperMessageEvent(
                         session_id=agent.session.id,
-                        item=model.DeveloperMessageItem(
-                            content="(no change)",
+                        item=message.DeveloperMessage(
+                            parts=message.text_parts_from_str("(no change)"),
                             command_output=model.CommandOutput(command_name=self.name),
                         ),
                     )

klaude_code/command/model_select.py

@@ -50,7 +50,7 @@ def select_model_interactive(preferred: str | None = None) -> str | None:
         selected = select_one(
             message=message,
             items=items,
-            pointer="->",
+            pointer="→",
             use_search_filter=True,
             initial_value=config.main_model,
             style=Style(

klaude_code/command/prompt-commit.md

@@ -0,0 +1,82 @@
+---
+description: Commit current git changes
+---
+
+## Workflow
+
+### Step 1: Detect version control system
+
+Check if `jj` is available in the current environment. (check in your <env> tag)
+
+### Step 2: Run pre-commit checks
+
+Before creating a commit, run the following checks:
+
+1. Run the project's linter to check and fix code style issues
+2. Run the project's test suite to ensure all tests pass
+3. If either check fails, stop the commit process and report the errors to the user
+4. If both checks pass, proceed to the next step
+
+### Step 3A: If jj is available
+
+1. Run `jj status` and `jj log -r 'ancestors(@, 10)'` to see working copy changes and the last 10 changes
+2. For each change that has no description (shows as "(no description set)"):
+   - Run `jj diff -r <change_id> --git` to view the diff
+   - Read related files if needed to understand the context
+   - Use `jj describe -r <change_id>` to add a meaningful description
+
+### Step 2B: If jj is not available (git)
+
+1. Run `git status` to check working directory state
+2. Run `git diff --cached` to check if there are staged changes
+3. If staging area has content:
+   - Ask the user: "Staging area has changes. Commit only staged changes, or stage and commit all changes?"
+   - If user chooses staged only: proceed with staged changes
+   - If user chooses all: run `git add -A` first
+4. If staging area is empty:
+   - Run `git add -A` to stage all changes
+5. Review the changes with `git diff --cached`
+6. Create the commit
+
+## Commit Message Format
+
+In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC:
+
+For jj:
+```bash
+jj describe -m "$(cat <<'EOF'
+Commit message here.
+EOF
+)"
+```
+
+For git:
+```bash
+git commit -m "$(cat <<'EOF'
+Commit message here.
+EOF
+)"
+```
+
+## Message Style
+
+Follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+
+```
+<type>(<scope>): <description>
+```
+
+Types:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, no logic change)
+- `refactor`: Code refactoring (no feature or fix)
+- `test`: Adding or updating tests
+- `chore`: Build process, dependencies, or tooling changes
+
+Examples:
+- `feat(cli): add --verbose flag for debug output`
+- `fix(llm): handle API timeout errors gracefully`
+- `docs(readme): update installation instructions`
+- `refactor(core): simplify session state management`

klaude_code/command/prompt_command.py

@@ -3,7 +3,7 @@ from importlib.resources import files
 import yaml
 
 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
 from klaude_code.trace import log_debug
 
 
@@ -55,7 +55,7 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
         user_input_text = user_input.text.strip() or "<none>"
@@ -71,7 +71,7 @@ class PromptCommand(CommandABC):
             operations=[
                 op.RunAgentOperation(
                     session_id=agent.session.id,
-                    input=model.UserInputPayload(text=final_prompt, images=user_input.images),
+                    input=message.UserInputPayload(text=final_prompt, images=user_input.images),
                 )
             ]
         )

klaude_code/command/refresh_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
 
 
 class RefreshTerminalCommand(CommandABC):
@@ -17,7 +17,7 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    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
 

klaude_code/command/registry.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import Agent, CommandResult
 from klaude_code.command.prompt_command import PromptCommand
-from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
@@ -133,7 +133,7 @@ def is_slash_command_name(name: str) -> bool:
     return _resolve_command_key(name) is not None
 
 
-async def dispatch_command(user_input: model.UserInputPayload, agent: Agent, *, submission_id: str) -> CommandResult:
+async def dispatch_command(user_input: message.UserInputPayload, agent: Agent, *, submission_id: str) -> CommandResult:
     _ensure_commands_loaded()
     # Detect command name
     raw = user_input.text
@@ -168,7 +168,7 @@ async def dispatch_command(user_input: model.UserInputPayload, agent: Agent, *,
     command_identifier: commands.CommandName | str = command.name
 
     try:
-        user_input_for_command = model.UserInputPayload(text=rest, images=user_input.images)
+        user_input_for_command = message.UserInputPayload(text=rest, images=user_input.images)
         result = await command.run(agent, user_input_for_command)
         ops = list(result.operations or [])
         for operation in ops:
@@ -187,8 +187,10 @@ async def dispatch_command(user_input: model.UserInputPayload, agent: Agent, *,
             events=[
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}",
+                    item=message.DeveloperMessage(
+                        parts=message.text_parts_from_str(
+                            f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}"
+                        ),
                         command_output=command_output,
                     ),
                 )

klaude_code/command/release_notes_cmd.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 
 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
 
 
 def _read_changelog() -> str:
@@ -68,15 +68,15 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    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
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 
         event = 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/resume_cmd.py

@@ -3,7 +3,7 @@ import asyncio
 from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.trace import log
 from klaude_code.ui.terminal.selector import SelectItem, select_one
@@ -35,14 +35,16 @@ def select_session_sync() -> str | None:
         display_msgs = format_user_messages_display(opt.user_messages)
         title: list[tuple[str, str]] = []
         title.append(("fg:ansibrightblack", f"{idx:2}. "))
-        title.append(
-            ("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name} · {opt.session_id}\n")
-        )
-        for msg in display_msgs:
+        title.append(("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name}"))
+        title.append(("fg:ansibrightblack dim", f" · {opt.session_id}\n"))
+        for i, msg in enumerate(display_msgs):
+            is_last = i == len(display_msgs) - 1
             if msg == "⋮":
                 title.append(("class:msg", f"    {msg}\n"))
             else:
-                title.append(("class:msg", f"    > {msg}\n"))
+                prefix = "└─" if is_last else "├─"
+                title.append(("fg:ansibrightblack dim", f"    {prefix} "))
+                title.append(("class:msg", f"{msg}\n"))
         title.append(("", "\n"))
 
         search_text = " ".join(opt.user_messages) + f" {opt.model_name} {opt.session_id}"
@@ -80,14 +82,16 @@ class ResumeCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    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
 
         if agent.session.messages_count > 0:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                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."
+                    ),
                     command_output=model.CommandOutput(command_name=self.name, is_error=True),
                 ),
             )
@@ -97,8 +101,8 @@ class ResumeCommand(CommandABC):
         if selected_session_id is None:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content="(no session selected)",
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str("(no session selected)"),
                     command_output=model.CommandOutput(command_name=self.name),
                 ),
             )

klaude_code/command/status_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.session.session import Session
 
 
@@ -132,15 +132,15 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    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
         session = agent.session
         aggregated = accumulate_session_usage(session)
 
         event = events.DeveloperMessageEvent(
             session_id=session.id,
-            item=model.DeveloperMessageItem(
-                content=format_status_content(aggregated),
+            item=message.DeveloperMessage(
+                parts=message.text_parts_from_str(format_status_content(aggregated)),
                 command_output=model.CommandOutput(
                     command_name=self.name,
                     ui_extra=model.SessionStatusUIExtra(

klaude_code/command/terminal_setup_cmd.py

@@ -3,7 +3,7 @@ import subprocess
 from pathlib import Path
 
 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
 
 
 class TerminalSetupCommand(CommandABC):
@@ -21,7 +21,7 @@ class TerminalSetupCommand(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:
         del user_input  # unused
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
@@ -221,28 +221,28 @@ class TerminalSetupCommand(CommandABC):
 
         return message
 
-    def _create_success_result(self, agent: "Agent", message: str) -> CommandResult:
+    def _create_success_result(self, agent: "Agent", msg: str) -> CommandResult:
         """Create success result"""
         return CommandResult(
             events=[
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=message,
+                    item=message.DeveloperMessage(
+                        parts=message.text_parts_from_str(msg),
                         command_output=model.CommandOutput(command_name=self.name, is_error=False),
                     ),
                 )
             ]
         )
 
-    def _create_error_result(self, agent: "Agent", message: str) -> CommandResult:
+    def _create_error_result(self, agent: "Agent", msg: str) -> CommandResult:
         """Create error result"""
         return CommandResult(
             events=[
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=message,
+                    item=message.DeveloperMessage(
+                        parts=message.text_parts_from_str(msg),
                         command_output=model.CommandOutput(command_name=self.name, is_error=True),
                     ),
                 )

klaude_code/command/thinking_cmd.py

@@ -4,7 +4,7 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.config.thinking import get_thinking_picker_data, parse_thinking_value
-from klaude_code.protocol import commands, events, llm_param, model, op
+from klaude_code.protocol import commands, events, llm_param, message, model, op
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 SELECT_STYLE = Style(
@@ -67,7 +67,7 @@ class ThinkingCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    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
         if agent.profile is None:
             return CommandResult(events=[])
@@ -80,8 +80,8 @@ class ThinkingCommand(CommandABC):
                 events=[
                     events.DeveloperMessageEvent(
                         session_id=agent.session.id,
-                        item=model.DeveloperMessageItem(
-                            content="(no change)",
+                        item=message.DeveloperMessage(
+                            parts=message.text_parts_from_str("(no change)"),
                             command_output=model.CommandOutput(command_name=self.name),
                         ),
                     )