klaude-code 2.3.0__py3-none-any.whl → 2.4.1__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

@@ -8,7 +8,7 @@ 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, model, op
+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
@@ -136,12 +136,11 @@ class SubAgentModelCommand(CommandABC):
         if not sub_agents:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("No sub-agents available"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="No sub-agents available",
+                        is_error=True,
                     )
                 ]
             )
@@ -150,12 +149,10 @@ class SubAgentModelCommand(CommandABC):
         if selected_sub_agent is None:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("(cancelled)"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="(cancelled)",
                     )
                 ]
             )
@@ -166,12 +163,10 @@ class SubAgentModelCommand(CommandABC):
         if selected_model is None:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("(cancelled)"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="(cancelled)",
                     )
                 ]
             )

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/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/developer.py

@@ -1,29 +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.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:
@@ -126,101 +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.STATUS:
-            return _render_status_output(command_output)
-        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)

klaude_code/tui/components/welcome.py

@@ -38,7 +38,7 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
     # Model line: model @ provider · params...
     panel_content.append_text(
         Text.assemble(
-            (str(e.llm_config.model), ThemeKey.WELCOME_HIGHLIGHT),
+            (str(e.llm_config.model_id), ThemeKey.WELCOME_HIGHLIGHT),
             (" @ ", ThemeKey.WELCOME_INFO),
             (e.llm_config.provider_name, ThemeKey.WELCOME_INFO),
         )
@@ -84,7 +84,7 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
                     (prefix, ThemeKey.LINES),
                     (sub_agent_type.lower().ljust(max_type_len), ThemeKey.WELCOME_INFO),
                     (": ", ThemeKey.LINES),
-                    (str(sub_llm_config.model), ThemeKey.WELCOME_HIGHLIGHT),
+                    (str(sub_llm_config.model_id), ThemeKey.WELCOME_HIGHLIGHT),
                     (" @ ", ThemeKey.WELCOME_INFO),
                     (sub_llm_config.provider_name, ThemeKey.WELCOME_INFO),
                 )

klaude_code/tui/input/prompt_toolkit.py

@@ -26,7 +26,7 @@ from prompt_toolkit.styles import Style
 from prompt_toolkit.utils import get_cwidth
 
 from klaude_code.config import load_config
-from klaude_code.config.config import ModelEntry
+from klaude_code.config.model_matcher import match_model_from_config
 from klaude_code.config.thinking import (
     format_current_thinking,
     get_thinking_picker_data,
@@ -452,23 +452,21 @@ class PromptToolkitInput(InputProviderABC):
     # -------------------------------------------------------------------------
 
     def _build_model_picker_items(self) -> tuple[list[SelectItem[str]], str | None]:
-        config = load_config()
-        models: list[ModelEntry] = sorted(
-            config.iter_model_entries(only_available=True),
-            key=lambda m: (m.model_name.lower(), m.provider.lower()),
-        )
-        if not models:
+        result = match_model_from_config()
+        if result.error_message or not result.filtered_models:
             return [], None
 
-        items = build_model_select_items(models)
+        items = build_model_select_items(result.filtered_models)
 
         initial = None
         if self._get_current_model_config_name is not None:
             with contextlib.suppress(Exception):
                 initial = self._get_current_model_config_name()
         if initial is None:
+            config = load_config()
             initial = config.main_model
         if isinstance(initial, str) and initial and "@" not in initial:
+            config = load_config()
             try:
                 resolved = config.resolve_model_location_prefer_available(initial) or config.resolve_model_location(
                     initial

klaude_code/tui/machine.py

@@ -21,6 +21,7 @@ from klaude_code.tui.commands import (
     PrintRuleLine,
     RenderAssistantImage,
     RenderCommand,
+    RenderCommandOutput,
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
@@ -365,6 +366,10 @@ class DisplayStateMachine:
                 cmds.append(RenderDeveloperMessage(e))
                 return cmds
 
+            case events.CommandOutputEvent() as e:
+                cmds.append(RenderCommandOutput(e))
+                return cmds
+
             case events.TurnStartEvent() as e:
                 cmds.append(RenderTurnStart(e))
                 self._spinner.clear_for_new_turn()

klaude_code/tui/renderer.py

@@ -31,6 +31,7 @@ from klaude_code.tui.commands import (
     PrintRuleLine,
     RenderAssistantImage,
     RenderCommand,
+    RenderCommandOutput,
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
@@ -53,6 +54,7 @@ from klaude_code.tui.commands import (
     TaskClockStart,
 )
 from klaude_code.tui.components import assistant as c_assistant
+from klaude_code.tui.components import command_output as c_command_output
 from klaude_code.tui.components import developer as c_developer
 from klaude_code.tui.components import errors as c_errors
 from klaude_code.tui.components import mermaid_viewer as c_mermaid_viewer
@@ -471,7 +473,6 @@ class TUICommandRenderer:
                             self.print()
                     case events.DeveloperMessageEvent() as e:
                         self.display_developer_message(e)
-                        self.display_command_output(e)
                     case events.UserMessageEvent() as e:
                         if is_sub_agent:
                             continue
@@ -504,11 +505,9 @@ class TUICommandRenderer:
         with self.session_print_context(e.session_id):
             self.print(c_developer.render_developer_message(e))
 
-    def display_command_output(self, e: events.DeveloperMessageEvent) -> None:
-        if not c_developer.get_command_output(e.item):
-            return
+    def display_command_output(self, e: events.CommandOutputEvent) -> None:
         with self.session_print_context(e.session_id):
-            self.print(c_developer.render_command_output(e))
+            self.print(c_command_output.render_command_output(e))
             self.print()
 
     def display_welcome(self, event: events.WelcomeEvent) -> None:
@@ -627,6 +626,7 @@ class TUICommandRenderer:
                     self.display_task_start(event)
                 case RenderDeveloperMessage(event=event):
                     self.display_developer_message(event)
+                case RenderCommandOutput(event=event):
                     self.display_command_output(event)
                 case RenderTurnStart(event=event):
                     self.display_turn_start(event)

klaude_code/tui/runner.py

@@ -76,14 +76,8 @@ async def submit_user_input_payload(
     if len(run_ops) > 1:
         raise ValueError("Multiple RunAgentOperation results are not supported")
 
-    for run_op in run_ops:
-        run_op.persist_user_input = cmd_result.persist
-        run_op.emit_user_message_event = False
-
     if cmd_result.events:
         for evt in cmd_result.events:
-            if cmd_result.persist and isinstance(evt, events.DeveloperMessageEvent):
-                agent.session.append_history([evt.item])
             await executor.context.emit_event(evt)
 
     submitted_ids: list[str] = []