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

klaude_code/config/{select_model.py → model_matcher.py}

@@ -51,7 +51,7 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
     # Only show models from providers with valid API keys
     models: list[ModelEntry] = sorted(
         config.iter_model_entries(only_available=True),
-        key=lambda m: (m.model_name.lower(), m.provider.lower()),
+        key=lambda m: (m.provider.lower(), m.model_name.lower()),
     )
 
     if not models:
@@ -86,13 +86,13 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
             return ModelMatchResult(matched_model=None, filtered_models=exact_base_matches, filter_hint=filter_hint)
 
         preferred_lower = preferred.lower()
-        # Case-insensitive exact match (selector/model_name/model_params.model)
+        # Case-insensitive exact match (selector/model_name/model_id)
         exact_ci_matches = [
             m
             for m in models
             if preferred_lower == m.selector.lower()
             or preferred_lower == m.model_name.lower()
-            or preferred_lower == (m.model_params.model or "").lower()
+            or preferred_lower == (m.model_id or "").lower()
         ]
         if len(exact_ci_matches) == 1:
             return ModelMatchResult(
@@ -110,7 +110,7 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
                 for m in models
                 if preferred_norm == _normalize_model_key(m.selector)
                 or preferred_norm == _normalize_model_key(m.model_name)
-                or preferred_norm == _normalize_model_key(m.model_params.model or "")
+                or preferred_norm == _normalize_model_key(m.model_id or "")
             ]
             if len(normalized_matches) == 1:
                 return ModelMatchResult(
@@ -125,7 +125,7 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
                     for m in models
                     if preferred_norm in _normalize_model_key(m.selector)
                     or preferred_norm in _normalize_model_key(m.model_name)
-                    or preferred_norm in _normalize_model_key(m.model_params.model or "")
+                    or preferred_norm in _normalize_model_key(m.model_id or "")
                 ]
                 if len(normalized_matches) == 1:
                     return ModelMatchResult(
@@ -134,14 +134,14 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
                         filter_hint=None,
                     )
 
-        # Partial match (case-insensitive) on model_name or model_params.model.
+        # Partial match (case-insensitive) on model_name or model_id.
         # If normalized matching found candidates (even if multiple), prefer those as the filter set.
         matches = normalized_matches or [
             m
             for m in models
             if preferred_lower in m.selector.lower()
             or preferred_lower in m.model_name.lower()
-            or preferred_lower in (m.model_params.model or "").lower()
+            or preferred_lower in (m.model_id or "").lower()
         ]
         if len(matches) == 1:
             return ModelMatchResult(matched_model=matches[0].selector, filtered_models=models, filter_hint=None)

klaude_code/config/sub_agent_model_helper.py

@@ -183,7 +183,7 @@ class SubAgentModelHelper:
         all_models = self._config.iter_model_entries(only_available=True)
 
         if profile.availability_requirement == AVAILABILITY_IMAGE_MODEL:
-            return [m for m in all_models if m.model_params.modalities and "image" in m.model_params.modalities]
+            return [m for m in all_models if m.modalities and "image" in m.modalities]
 
         return all_models
 

klaude_code/config/thinking.py

@@ -104,7 +104,7 @@ def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
         return "not set"
 
     if protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        if is_openrouter_model_with_reasoning_effort(config.model):
+        if is_openrouter_model_with_reasoning_effort(config.model_id):
             if thinking.reasoning_effort:
                 return f"reasoning_effort={thinking.reasoning_effort}"
         else:
@@ -198,7 +198,7 @@ def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPi
         ThinkingPickerData with options and current value, or None if protocol doesn't support thinking.
     """
     protocol = config.protocol
-    model_name = config.model
+    model_name = config.model_id
     thinking = config.thinking
 
     if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX_OAUTH):

klaude_code/core/executor.py

@@ -162,27 +162,16 @@ class AgentRuntime:
 
     async def run_agent(self, operation: op.RunAgentOperation) -> None:
         agent = await self.ensure_agent(operation.session_id)
-
-        if operation.emit_user_message_event:
-            await self._emit_event(
-                events.UserMessageEvent(
-                    content=operation.input.text,
-                    session_id=agent.session.id,
-                    images=operation.input.images,
-                )
-            )
-
-        if operation.persist_user_input:
-            agent.session.append_history(
-                [
-                    message.UserMessage(
-                        parts=message.parts_from_text_and_images(
-                            operation.input.text,
-                            operation.input.images,
-                        )
+        agent.session.append_history(
+            [
+                message.UserMessage(
+                    parts=message.parts_from_text_and_images(
+                        operation.input.text,
+                        operation.input.images,
                     )
-                ]
-            )
+                )
+            ]
+        )
 
         existing_active = self._task_manager.get(operation.id)
         if existing_active is not None and not existing_active.task.done():
@@ -201,11 +190,13 @@ class AgentRuntime:
         new_session.model_thinking = agent.session.model_thinking
         agent.session = new_session
 
-        developer_item = message.DeveloperMessage(
-            parts=message.text_parts_from_str("started new conversation"),
-            ui_extra=model.build_command_output_extra(commands.CommandName.CLEAR),
+        await self._emit_event(
+            events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=commands.CommandName.CLEAR,
+                content="started new conversation",
+            )
         )
-        await self._emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
         await self._emit_event(
             events.WelcomeEvent(
                 session_id=agent.session.id,
@@ -460,12 +451,13 @@ class ExecutorContext:
 
         if operation.emit_switch_message:
             default_note = " (saved as default)" if operation.save_as_default else ""
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Switched to: {llm_config.model}{default_note}"),
-                ui_extra=model.build_command_output_extra(commands.CommandName.MODEL),
+            await self.emit_event(
+                events.CommandOutputEvent(
+                    session_id=agent.session.id,
+                    command_name=commands.CommandName.MODEL,
+                    content=f"Switched to: {llm_config.model_id}{default_note}",
+                )
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
         if self._on_model_change is not None:
             self._on_model_change(llm_client_name)
@@ -510,12 +502,13 @@ class ExecutorContext:
         new_status = _format_thinking_for_display(operation.thinking)
 
         if operation.emit_switch_message:
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Thinking changed: {current} -> {new_status}"),
-                ui_extra=model.build_command_output_extra(commands.CommandName.THINKING),
+            await self.emit_event(
+                events.CommandOutputEvent(
+                    session_id=agent.session.id,
+                    command_name=commands.CommandName.THINKING,
+                    content=f"Thinking changed: {current} -> {new_status}",
+                )
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
         if operation.emit_welcome_event:
             await self.emit_event(
@@ -572,12 +565,13 @@ class ExecutorContext:
             await config.save()
 
         saved_note = " (saved in ~/.klaude/klaude-config.yaml)" if operation.save_as_default else ""
-        developer_item = message.DeveloperMessage(
-            parts=message.text_parts_from_str(f"{sub_agent_type} model: {display_model}{saved_note}"),
-            ui_extra=model.build_command_output_extra(commands.CommandName.SUB_AGENT_MODEL),
+        await self.emit_event(
+            events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=commands.CommandName.SUB_AGENT_MODEL,
+                content=f"{sub_agent_type} model: {display_model}{saved_note}",
+            )
         )
-        agent.session.append_history([developer_item])
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         await self._agent_runtime.clear_session(operation.session_id)
@@ -593,21 +587,24 @@ class ExecutorContext:
             await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
             await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
             await asyncio.to_thread(self._open_file, output_path)
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Session exported and opened: {output_path}"),
-                ui_extra=model.build_command_output_extra(commands.CommandName.EXPORT),
+            await self.emit_event(
+                events.CommandOutputEvent(
+                    session_id=agent.session.id,
+                    command_name=commands.CommandName.EXPORT,
+                    content=f"Session exported and opened: {output_path}",
+                )
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
         except Exception as exc:  # pragma: no cover
             import traceback
 
-            developer_item = message.DeveloperMessage(
-                parts=message.text_parts_from_str(f"Failed to export session: {exc}\n{traceback.format_exc()}"),
-                ui_extra=model.build_command_output_extra(commands.CommandName.EXPORT, is_error=True),
+            await self.emit_event(
+                events.CommandOutputEvent(
+                    session_id=agent.session.id,
+                    command_name=commands.CommandName.EXPORT,
+                    content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+                    is_error=True,
+                )
             )
-            agent.session.append_history([developer_item])
-            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
     def _resolve_export_output_path(self, raw: str | None, session: Session) -> Path:
         trimmed = (raw or "").strip()
@@ -701,12 +698,15 @@ class Executor:
             Unique submission ID for tracking
         """
 
-        submission = op.Submission(id=operation.id, operation=operation)
-        await self.submission_queue.put(submission)
+        if operation.id in self._completion_events:
+            raise RuntimeError(f"Submission already registered: {operation.id}")
 
-        # Create completion event for tracking
+        # Create completion event before queueing to avoid races.
         self._completion_events[operation.id] = asyncio.Event()
 
+        submission = op.Submission(id=operation.id, operation=operation)
+        await self.submission_queue.put(submission)
+
         log_debug(
             f"Submitted operation {operation.type} with ID {operation.id}",
             style="blue",
@@ -786,9 +786,16 @@ class Executor:
         if tasks_to_await:
             await asyncio.gather(*tasks_to_await, return_exceptions=True)
 
+        if self._background_tasks:
+            await asyncio.gather(*self._background_tasks, return_exceptions=True)
+            self._background_tasks.clear()
+
         # Clear the active task manager
         self.context.task_manager.clear()
 
+        for event in self._completion_events.values():
+            event.set()
+
         # Send EndOperation to wake up the start() loop
         try:
             end_operation = op.EndOperation()

klaude_code/core/tool/file/diff_builder.py

@@ -54,24 +54,31 @@ def _build_file_diff(before: str, after: str, *, file_path: str) -> model.DiffFi
             elif tag == "replace":
                 old_block = before_lines[i1:i2]
                 new_block = after_lines[j1:j2]
-                max_len = max(len(old_block), len(new_block))
-                for idx in range(max_len):
-                    old_line = old_block[idx] if idx < len(old_block) else None
-                    new_line = new_block[idx] if idx < len(new_block) else None
-                    if old_line is not None and new_line is not None:
-                        remove_spans, add_spans = _diff_line_spans(old_line, new_line)
-                        lines.append(_remove_line(remove_spans))
-                        lines.append(_add_line(add_spans, new_line_no))
-                        stats_remove += 1
-                        stats_add += 1
-                        new_line_no += 1
-                    elif old_line is not None:
-                        lines.append(_remove_line([model.DiffSpan(op="equal", text=old_line)]))
-                        stats_remove += 1
-                    elif new_line is not None:
-                        lines.append(_add_line([model.DiffSpan(op="equal", text=new_line)], new_line_no))
-                        stats_add += 1
-                        new_line_no += 1
+
+                # Emit replacement blocks in unified-diff style: all removals first, then all additions.
+                # This matches VSCode's readability (--- then +++), while keeping per-line char spans.
+                remove_block: list[list[model.DiffSpan]] = []
+                add_block: list[list[model.DiffSpan]] = []
+
+                paired_len = min(len(old_block), len(new_block))
+                for idx in range(paired_len):
+                    remove_spans, add_spans = _diff_line_spans(old_block[idx], new_block[idx])
+                    remove_block.append(remove_spans)
+                    add_block.append(add_spans)
+
+                for old_line in old_block[paired_len:]:
+                    remove_block.append([model.DiffSpan(op="equal", text=old_line)])
+                for new_line in new_block[paired_len:]:
+                    add_block.append([model.DiffSpan(op="equal", text=new_line)])
+
+                for spans in remove_block:
+                    lines.append(_remove_line(spans))
+                    stats_remove += 1
+
+                for spans in add_block:
+                    lines.append(_add_line(spans, new_line_no))
+                    stats_add += 1
+                    new_line_no += 1
 
     return model.DiffFileDiff(
         file_path=file_path,

klaude_code/llm/anthropic/client.py

@@ -65,7 +65,7 @@ def build_payload(
         param: LLM call parameters.
         extra_betas: Additional beta flags to prepend to the betas list.
     """
-    messages = convert_history_to_input(param.input, param.model)
+    messages = convert_history_to_input(param.input, param.model_id)
     tools = convert_tool_schema(param.tools)
     system_messages = [msg for msg in param.input if isinstance(msg, message.SystemMessage)]
     system = convert_system_to_input(param.system, system_messages)
@@ -89,7 +89,7 @@ def build_payload(
     }
 
     payload: MessageCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": tool_choice,
         "stream": True,
         "max_tokens": param.max_tokens or DEFAULT_MAX_TOKENS,
@@ -186,12 +186,12 @@ async def parse_anthropic_stream(
                 if accumulated_thinking:
                     metadata_tracker.record_token()
                     full_thinking = "".join(accumulated_thinking)
-                    parts.append(message.ThinkingTextPart(text=full_thinking, model_id=str(param.model)))
+                    parts.append(message.ThinkingTextPart(text=full_thinking, model_id=str(param.model_id)))
                     if pending_signature:
                         parts.append(
                             message.ThinkingSignaturePart(
                                 signature=pending_signature,
-                                model_id=str(param.model),
+                                model_id=str(param.model_id),
                                 format="anthropic",
                             )
                         )
@@ -224,7 +224,7 @@ async def parse_anthropic_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)
                 raw_stop_reason = getattr(event, "stop_reason", None)
                 if isinstance(raw_stop_reason, str):

klaude_code/llm/client.py

@@ -25,7 +25,7 @@ class LLMClientABC(ABC):
 
     @property
     def model_name(self) -> str:
-        return self._config.model or ""
+        return self._config.model_id or ""
 
     @property
     def protocol(self) -> llm_param.LLMClientProtocol:

klaude_code/llm/codex/client.py

@@ -31,13 +31,13 @@ from klaude_code.protocol import llm_param, message
 
 def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
     """Build Codex 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)
 
     session_id = param.session_id or ""
 
     payload: ResponseCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "include": [

klaude_code/llm/google/client.py

@@ -163,7 +163,7 @@ async def parse_google_stream(
             assistant_parts.append(
                 message.ThinkingTextPart(
                     text="".join(accumulated_thoughts),
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                 )
             )
             accumulated_thoughts.clear()
@@ -171,7 +171,7 @@ async def parse_google_stream(
             assistant_parts.append(
                 message.ThinkingSignaturePart(
                     signature=thought_signature,
-                    model_id=str(param.model),
+                    model_id=str(param.model_id),
                     format="google_thought_signature",
                 )
             )
@@ -301,7 +301,7 @@ async def parse_google_stream(
     usage = _usage_from_metadata(last_usage_metadata, context_limit=param.context_limit, max_tokens=param.max_tokens)
     if usage is not None:
         metadata_tracker.set_usage(usage)
-    metadata_tracker.set_model_name(str(param.model))
+    metadata_tracker.set_model_name(str(param.model_id))
     metadata_tracker.set_response_id(response_id)
     metadata = metadata_tracker.finalize()
     yield message.AssistantMessage(
@@ -336,13 +336,13 @@ class GoogleClient(LLMClientABC):
         param = apply_config_defaults(param, self.get_llm_config())
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        contents = convert_history_to_contents(param.input, model_name=str(param.model))
+        contents = convert_history_to_contents(param.input, model_name=str(param.model_id))
         config = _build_config(param)
 
         log_debug(
             json.dumps(
                 {
-                    "model": str(param.model),
+                    "model": str(param.model_id),
                     "contents": [c.model_dump(exclude_none=True) for c in contents],
                     "config": config.model_dump(exclude_none=True),
                 },
@@ -354,7 +354,7 @@ class GoogleClient(LLMClientABC):
 
         try:
             stream = await self.client.aio.models.generate_content_stream(
-                model=str(param.model),
+                model=str(param.model_id),
                 contents=cast(Any, contents),
                 config=config,
             )

klaude_code/llm/input_common.py

@@ -165,8 +165,8 @@ def split_thinking_parts(
 
 def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter") -> "LLMCallParameter":
     """Apply config defaults to LLM call parameters."""
-    if param.model is None:
-        param.model = config.model
+    if param.model_id is None:
+        param.model_id = config.model_id
     if param.temperature is None:
         param.temperature = config.temperature
     if param.max_tokens is None:

klaude_code/llm/openai_compatible/client.py

@@ -19,7 +19,7 @@ from klaude_code.protocol import llm_param, message
 
 def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:
     """Build OpenAI 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] = {}
@@ -31,7 +31,7 @@ def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreatePa
         }
 
     payload: CompletionCreateParamsStreaming = {
-        "model": str(param.model),
+        "model": str(param.model_id),
         "tool_choice": "auto",
         "parallel_tool_calls": True,
         "stream": True,
@@ -108,7 +108,7 @@ class OpenAICompatibleClient(LLMClientABC):
             return
 
         reasoning_handler = DefaultReasoningHandler(
-            param_model=str(param.model),
+            param_model=str(param.model_id),
             response_id=None,
         )
 

klaude_code/llm/openai_compatible/stream.py

@@ -179,7 +179,7 @@ async def parse_chat_completions_stream(
     """
 
     state = StreamStateManager(
-        param_model=str(param.model),
+        param_model=str(param.model_id),
         reasoning_flusher=reasoning_handler.flush,
     )
 

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