klaude-code 2.3.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

klaude_code/llm/openrouter/client.py

@@ -30,7 +30,7 @@ def build_payload(
     param: llm_param.LLMCallParameter,
 ) -> tuple[CompletionCreateParamsStreaming, dict[str, object], dict[str, str]]:
     """Build OpenRouter API request parameters."""
-    messages = convert_history_to_input(param.input, param.system, param.model)
+    messages = convert_history_to_input(param.input, param.system, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     extra_body: dict[str, object] = {
@@ -66,13 +66,13 @@ def build_payload(
     if param.provider_routing:
         extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
 
-    if is_claude_model(param.model):
+    if is_claude_model(param.model_id):
         extra_headers["x-anthropic-beta"] = (
             f"{ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING},{ANTHROPIC_BETA_INTERLEAVED_THINKING}"
         )
 
     payload: CompletionCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "stream": True,
@@ -133,7 +133,7 @@ class OpenRouterClient(LLMClientABC):
             return
 
         reasoning_handler = ReasoningStreamHandler(
-            param_model=str(param.model),
+            param_model=str(param.model_id),
             response_id=None,
         )
 

klaude_code/llm/openrouter/input.py

@@ -115,9 +115,7 @@ def convert_history_to_input(
             )
         ]
         if system and use_cache_control
-        else (
-            [cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system})] if system else []
-        )
+        else ([cast(chat.ChatCompletionMessageParam, {"role": "system", "content": system})] if system else [])
     )
 
     for msg, attachment in attach_developer_messages(history):

klaude_code/llm/responses/client.py

@@ -24,11 +24,11 @@ if TYPE_CHECKING:
 
 def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
     """Build OpenAI Responses API request parameters."""
-    inputs = convert_history_to_input(param.input, param.model)
+    inputs = convert_history_to_input(param.input, param.model_id)
     tools = convert_tool_schema(param.tools)
 
     payload: ResponseCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "include": [
@@ -77,7 +77,7 @@ async def parse_responses_stream(
             assistant_parts.append(
                 message.ThinkingTextPart(
                     text="".join(accumulated_thinking),
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                 )
             )
             accumulated_thinking.clear()
@@ -85,7 +85,7 @@ async def parse_responses_stream(
             assistant_parts.append(
                 message.ThinkingSignaturePart(
                     signature=pending_signature,
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                     format="openai_reasoning",
                 )
             )
@@ -197,7 +197,7 @@ async def parse_responses_stream(
                                 max_tokens=param.max_tokens,
                             )
                         )
-                    metadata_tracker.set_model_name(str(param.model))
+                    metadata_tracker.set_model_name(str(param.model_id))
                     metadata_tracker.set_response_id(response_id)
                     stop_reason = map_stop_reason(event.response.status, error_reason)
                     if event.response.status != "completed":

klaude_code/protocol/events/__init__.py

@@ -1,7 +1,12 @@
 from __future__ import annotations
 
 from klaude_code.protocol.events.base import Event, ResponseEvent
-from klaude_code.protocol.events.chat import DeveloperMessageEvent, TodoChangeEvent, UserMessageEvent
+from klaude_code.protocol.events.chat import (
+    CommandOutputEvent,
+    DeveloperMessageEvent,
+    TodoChangeEvent,
+    UserMessageEvent,
+)
 from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnEndEvent, TurnStartEvent
 from klaude_code.protocol.events.metadata import TaskMetadataEvent, UsageEvent
 from klaude_code.protocol.events.streaming import (
@@ -30,6 +35,7 @@ __all__ = [
     "AssistantTextDeltaEvent",
     "AssistantTextEndEvent",
     "AssistantTextStartEvent",
+    "CommandOutputEvent",
     "DeveloperMessageEvent",
     "EndEvent",
     "ErrorEvent",

klaude_code/protocol/events/chat.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from klaude_code.protocol import message, model
+from klaude_code.protocol.commands import CommandName
 
 from .base import Event
 
@@ -18,3 +19,12 @@ class DeveloperMessageEvent(Event):
 
 class TodoChangeEvent(Event):
     todos: list[model.TodoItem]
+
+
+class CommandOutputEvent(Event):
+    """Event for command output display. Not persisted to session history."""
+
+    command_name: CommandName | str
+    content: str = ""
+    ui_extra: model.ToolResultUIExtra | None = None
+    is_error: bool = False

klaude_code/protocol/llm_param.py

@@ -119,7 +119,7 @@ class LLMConfigProviderParameter(BaseModel):
 
 
 class LLMConfigModelParameter(BaseModel):
-    model: str | None = None
+    model_id: str | None = None
     temperature: float | None = None
     max_tokens: int | None = None
     context_limit: int | None = None

klaude_code/protocol/model.py

@@ -5,7 +5,6 @@ from typing import Annotated, Any, Literal
 from pydantic import BaseModel, Field, computed_field
 
 from klaude_code.const import DEFAULT_MAX_TOKENS
-from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
 
 RoleType = Literal["system", "developer", "user", "assistant", "tool"]
@@ -272,12 +271,6 @@ ToolResultUIExtra = Annotated[
 ]
 
 
-class CommandOutput(BaseModel):
-    command_name: CommandName
-    ui_extra: ToolResultUIExtra | None = None
-    is_error: bool = False
-
-
 class MemoryFileLoaded(BaseModel):
     path: str
     mentioned_patterns: list[str] = Field(default_factory=list)
@@ -319,11 +312,6 @@ class SkillActivatedUIItem(BaseModel):
     name: str
 
 
-class CommandOutputUIItem(BaseModel):
-    type: Literal["command_output"] = "command_output"
-    output: CommandOutput
-
-
 type DeveloperUIItem = (
     MemoryLoadedUIItem
     | ExternalFileChangesUIItem
@@ -331,7 +319,6 @@ type DeveloperUIItem = (
     | AtFileOpsUIItem
     | UserImagesUIItem
     | SkillActivatedUIItem
-    | CommandOutputUIItem
 )
 
 
@@ -343,19 +330,6 @@ class DeveloperUIExtra(BaseModel):
     items: list[DeveloperUIItem] = Field(default_factory=_empty_developer_ui_items)
 
 
-def build_command_output_extra(
-    command_name: CommandName,
-    *,
-    ui_extra: ToolResultUIExtra | None = None,
-    is_error: bool = False,
-) -> DeveloperUIExtra:
-    return DeveloperUIExtra(
-        items=[
-            CommandOutputUIItem(output=CommandOutput(command_name=command_name, ui_extra=ui_extra, is_error=is_error))
-        ]
-    )
-
-
 class SubAgentState(BaseModel):
     sub_agent_type: SubAgentType
     sub_agent_desc: str

klaude_code/protocol/op.py

@@ -52,11 +52,6 @@ class RunAgentOperation(Operation):
     type: OperationType = OperationType.RUN_AGENT
     session_id: str
     input: UserInputPayload
-    # Frontends may choose to render the user message themselves (e.g. TUI) to support
-    # event-only commands; in that case the core should skip emitting the UserMessageEvent.
-    emit_user_message_event: bool = True
-    # Frontends may choose to run without persisting input (e.g. some interactive commands).
-    persist_user_input: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_run_agent(self)

klaude_code/session/session.py

@@ -237,7 +237,7 @@ class Session(BaseModel):
         Args:
             new_id: Optional ID for the forked session.
             until_index: If provided, only copy conversation history up to (but not including) this index.
-                         If None, copy all history.
+                         If -1, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -250,7 +250,9 @@ class Session(BaseModel):
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
         history_to_copy = (
-            self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+            self.conversation_history[:until_index]
+            if (until_index is not None and until_index >= 0)
+            else self.conversation_history
         )
         items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:

klaude_code/tui/command/clear_cmd.py

@@ -22,5 +22,4 @@ class ClearCommand(CommandABC):
 
         return CommandResult(
             operations=[op.ClearSessionOperation(session_id=agent.session.id)],
-            persist=False,
         )

klaude_code/tui/command/command_abc.py

@@ -37,14 +37,16 @@ class CommandResult(BaseModel):
     """Result of a command execution."""
 
     events: (
-        list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
+        list[
+            protocol_events.CommandOutputEvent
+            | protocol_events.ErrorEvent
+            | protocol_events.WelcomeEvent
+            | protocol_events.ReplayHistoryEvent
+        ]
         | None
     ) = None  # List of UI events to display immediately
     operations: list[op.Operation] | None = None
 
-    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
-    persist: bool = True
-
 
 class CommandABC(ABC):
     """Abstract base class for slash commands."""

klaude_code/tui/command/copy_cmd.py

@@ -1,4 +1,4 @@
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.tui.input.clipboard import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -20,10 +20,10 @@ class CopyCommand(CommandABC):
 
         last = _get_last_assistant_text(agent.session.conversation_history)
         if not last:
-            return _developer_message(agent, "(no assistant message to copy)", self.name)
+            return _command_output(agent, "(no assistant message to copy)", self.name, is_error=True)
 
         copy_to_clipboard(last)
-        return _developer_message(agent, "Copied last assistant message to clipboard.", self.name)
+        return _command_output(agent, "Copied last assistant message to clipboard.", self.name)
 
 
 def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
@@ -37,16 +37,16 @@ def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
     return ""
 
 
-def _developer_message(agent: Agent, content: str, command_name: commands.CommandName) -> CommandResult:
+def _command_output(
+    agent: Agent, content: str, command_name: commands.CommandName, *, is_error: bool = False
+) -> CommandResult:
     return CommandResult(
         events=[
-            events.DeveloperMessageEvent(
+            events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(content),
-                    ui_extra=model.build_command_output_extra(command_name),
-                ),
+                command_name=command_name,
+                content=content,
+                is_error=is_error,
             )
         ],
-        persist=False,
     )

klaude_code/tui/command/debug_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.log import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 
 from .command_abc import Agent, CommandABC, CommandResult
 
@@ -52,7 +52,7 @@ class DebugCommand(CommandABC):
         # /debug (no args) - enable debug
         if not raw:
             set_debug_logging(True, write_to_file=True)
-            return self._message_result(agent, _format_status())
+            return self._command_output(agent, _format_status())
 
         # /debug <filters> - enable with filters
         try:
@@ -60,21 +60,22 @@ class DebugCommand(CommandABC):
             if filters:
                 set_debug_logging(True, write_to_file=True, filters=filters)
                 filter_names = ", ".join(sorted(dt.value for dt in filters))
-                return self._message_result(agent, f"Filters: {filter_names}\n{_format_status()}")
+                return self._command_output(agent, f"Filters: {filter_names}\n{_format_status()}")
         except ValueError:
             pass
 
-        return self._message_result(agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}")
+        return self._command_output(
+            agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}", is_error=True
+        )
 
-    def _message_result(self, agent: "Agent", content: str) -> CommandResult:
+    def _command_output(self, agent: "Agent", content: str, *, is_error: bool = False) -> CommandResult:
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(content),
-                        ui_extra=model.build_command_output_extra(self.name),
-                    ),
+                    command_name=self.name,
+                    content=content,
+                    is_error=is_error,
                 )
             ]
         )

klaude_code/tui/command/export_online_cmd.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.text import Text
 
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.session.export import build_export_html
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -39,54 +39,49 @@ class ExportOnlineCommand(CommandABC):
         # Check if npx or surge is available
         surge_cmd = self._get_surge_command()
         if not surge_cmd:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("surge.sh CLI not found. Install with: npm install -g surge"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content="surge.sh CLI not found. Install with: npm install -g surge",
+                is_error=True,
             )
             return CommandResult(events=[event])
 
         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(
+                event = events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(f"Not logged in to surge.sh. Please run: {login_cmd}"),
-                        ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                    ),
+                    command_name=self.name,
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    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(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session deployed to: {url}"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content=f"Session deployed to: {url}",
             )
             return CommandResult(events=[event])
         except Exception as exc:
             import traceback
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Failed to deploy session: {exc}\n{traceback.format_exc()}"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                is_error=True,
             )
             return CommandResult(events=[event])
 

klaude_code/tui/command/fork_session_cmd.py

@@ -31,7 +31,7 @@ FORK_SELECT_STYLE = Style(
 class ForkPoint:
     """A fork point in conversation history."""
 
-    history_index: int | None  # None means fork entire conversation
+    history_index: int  # -1 means fork entire conversation
     user_message: str
     tool_call_stats: dict[str, int]  # tool_name -> count
     last_assistant_summary: str
@@ -94,7 +94,7 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     if user_indices:
         fork_points.append(
             ForkPoint(
-                history_index=None,  # None means fork entire conversation
+                history_index=-1,  # None means fork entire conversation
                 user_message="",  # No specific message, this represents the end
                 tool_call_stats={},
                 last_assistant_summary="",
@@ -104,9 +104,9 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     return fork_points
 
 
-def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
     """Build SelectItem list from fork points."""
-    items: list[SelectItem[int | None]] = []
+    items: list[SelectItem[int]] = []
 
     for i, fp in enumerate(fork_points):
         is_first = i == 0
@@ -116,8 +116,8 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
         title_parts: list[tuple[str, str]] = []
 
         # First line: separator (with special markers for first/last fork points)
-        if is_first and not is_last:
-            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        if is_first:
+            pass
         elif is_last:
             title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
         else:
@@ -150,17 +150,16 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
     return items
 
 
-def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | Literal["cancelled"]:
     """Interactive fork point selection (sync version for asyncio.to_thread).
 
     Returns:
-        - int: history index to fork at (exclusive)
-        - None: fork entire conversation
+        - int: history index to fork at (exclusive), -1 means fork entire conversation
         - "cancelled": user cancelled selection
     """
     items = _build_select_items(fork_points)
     if not items:
-        return None
+        return -1
 
     # Default to the last option (fork entire conversation)
     last_value = items[-1].value
@@ -204,14 +203,13 @@ class ForkSessionCommand(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("(no messages to fork)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(no messages to fork)",
+                is_error=True,
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Build fork points from conversation history
         fork_points = _build_fork_points(agent.session.conversation_history)
@@ -224,51 +222,49 @@ class ForkSessionCommand(CommandABC):
             resume_cmd = f"klaude --resume-by-id {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session forked successfully. New session id: {new_session.id}"),
-                    ui_extra=model.build_command_output_extra(
-                        self.name,
-                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                    ),
-                ),
+                command_name=self.name,
+                content=f"Session forked successfully. New session id: {new_session.id}",
+                ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Interactive selection
         selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
 
         if selected == "cancelled":
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(fork cancelled)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(fork cancelled)",
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
+
+        # First option (empty session) is just for UI display, not a valid fork point
+        if selected == fork_points[0].history_index:
+            event = events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=self.name,
+                content="(cannot fork to empty session)",
+                is_error=True,
+            )
+            return CommandResult(events=[event])
 
         # Perform the fork
         new_session = agent.session.fork(until_index=selected)
         await new_session.wait_for_flush()
 
         # Build result message
-        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+        fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
         resume_cmd = f"klaude --resume-by-id {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
-        event = events.DeveloperMessageEvent(
+        event = events.CommandOutputEvent(
             session_id=agent.session.id,
-            item=message.DeveloperMessage(
-                parts=message.text_parts_from_str(
-                    f"Session forked ({fork_description}). New session id: {new_session.id}"
-                ),
-                ui_extra=model.build_command_output_extra(
-                    self.name,
-                    ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                ),
-            ),
+            command_name=self.name,
+            content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+            ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
         )
-        return CommandResult(events=[event], persist=False)
+        return CommandResult(events=[event])

klaude_code/tui/command/model_cmd.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 
 from .command_abc import Agent, CommandABC, CommandResult
-from .model_select import ModelSelectStatus, select_model_interactive
+from .model_picker import ModelSelectStatus, select_model_interactive
 
 
 class ModelCommand(CommandABC):
@@ -37,12 +37,10 @@ class ModelCommand(CommandABC):
         if selected_model is None or selected_model == current_model:
             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/command/{model_select.py → model_picker.py}

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from enum import Enum
 
 from klaude_code.config.config import load_config
-from klaude_code.config.select_model import match_model_from_config
+from klaude_code.config.model_matcher import match_model_from_config
 from klaude_code.log import log
 
 
@@ -35,7 +35,7 @@ def select_model_interactive(
     This function combines matching logic with interactive UI selection.
     For CLI usage.
 
-    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_params.model.
+    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_id.
 
     If preferred is provided:
     - Exact match: return immediately
@@ -54,9 +54,7 @@ def select_model_interactive(
     if keywords:
         keywords_lower = [k.lower() for k in keywords]
         filtered_models = [
-            m
-            for m in result.filtered_models
-            if any(kw in (m.model_params.model or "").lower() for kw in keywords_lower)
+            m for m in result.filtered_models if any(kw in (m.model_id or "").lower() for kw in keywords_lower)
         ]
         if not filtered_models:
             return ModelSelectResult(status=ModelSelectStatus.NO_MATCH)

klaude_code/tui/command/refresh_cmd.py

@@ -38,5 +38,4 @@ class RefreshTerminalCommand(CommandABC):
                     is_load=False,
                 ),
             ],
-            persist=False,
         )