klaude-code 2.3.0__py3-none-any.whl → 2.4.1__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
 
@@ -196,15 +196,6 @@ class SubAgentModelHelper:
                 result.append(name)
         return result
 
-    def get_enabled_sub_agent_types(self) -> set[SubAgentType]:
-        """Return set of sub-agent types that are enabled and available."""
-        enabled: set[SubAgentType] = set()
-        for name in sub_agent_tool_names(enabled_only=True):
-            profile = get_sub_agent_profile_by_tool(name)
-            if profile is not None and self.check_availability_requirement(profile.availability_requirement):
-                enabled.add(profile.name)
-        return enabled
-
     def build_sub_agent_client_configs(self) -> dict[SubAgentType, str]:
         """Return model names for each sub-agent that needs a dedicated client."""
         result: dict[SubAgentType, str] = {}

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

@@ -262,10 +262,6 @@ class ModelProfileProvider(Protocol):
         output_schema: dict[str, Any] | None = None,
     ) -> AgentProfile: ...
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        """Return set of sub-agent types enabled for this provider."""
-        ...
-
 
 class DefaultModelProfileProvider(ModelProfileProvider):
     """Default provider backed by global prompts/tool/reminder registries."""
@@ -281,28 +277,24 @@ class DefaultModelProfileProvider(ModelProfileProvider):
         output_schema: dict[str, Any] | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
+        llm_config = llm_client.get_llm_config()
+
+        # Image generation models should not have tools
+        if llm_config.modalities and "image" in llm_config.modalities:
+            agent_tools: list[llm_param.ToolSchema] = []
+        else:
+            agent_tools = load_agent_tools(model_name, sub_agent_type, config=self._config)
+
         profile = AgentProfile(
             llm_client=llm_client,
             system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
-            tools=load_agent_tools(model_name, sub_agent_type, config=self._config),
+            tools=agent_tools,
             reminders=load_agent_reminders(model_name, sub_agent_type),
         )
         if output_schema:
             return with_structured_output(profile, output_schema)
         return profile
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        if self._config is None:
-            from klaude_code.protocol.sub_agent import get_sub_agent_profile_by_tool, sub_agent_tool_names
-
-            return {
-                profile.name
-                for name in sub_agent_tool_names(enabled_only=True)
-                if (profile := get_sub_agent_profile_by_tool(name)) is not None
-            }
-        helper = SubAgentModelHelper(self._config)
-        return helper.get_enabled_sub_agent_types()
-
 
 class VanillaModelProfileProvider(ModelProfileProvider):
     """Provider that strips prompts, reminders, and tools for vanilla mode."""
@@ -325,9 +317,6 @@ class VanillaModelProfileProvider(ModelProfileProvider):
             return with_structured_output(profile, output_schema)
         return profile
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        return set()
-
 
 class NanoBananaModelProfileProvider(ModelProfileProvider):
     """Provider for the Nano Banana image generation model.
@@ -352,6 +341,3 @@ class NanoBananaModelProfileProvider(ModelProfileProvider):
         if output_schema:
             return with_structured_output(profile, output_schema)
         return profile
-
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        return set()

klaude_code/core/executor.py

@@ -17,14 +17,14 @@ from pathlib import Path
 from klaude_code.config import load_config
 from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
 from klaude_code.core.agent import Agent
-from klaude_code.core.agent_profile import DefaultModelProfileProvider, ModelProfileProvider
+from klaude_code.core.agent_profile import AgentProfile, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.protocol.llm_param import LLMConfigParameter, Thinking
 from klaude_code.protocol.op_handler import OperationHandler
-from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.protocol.sub_agent import SubAgentResult, get_sub_agent_profile_by_tool
 from klaude_code.session.export import build_export_html, get_default_export_path
 from klaude_code.session.session import Session
 
@@ -110,13 +110,17 @@ class AgentRuntime:
     def current_agent(self) -> Agent | None:
         return self._agent
 
-    def _get_sub_agent_models(self) -> dict[str, LLMConfigParameter]:
-        """Build a dict of sub-agent type to LLMConfigParameter."""
-        enabled = self._model_profile_provider.enabled_sub_agent_types()
+    def _get_sub_agent_models(self, profile: AgentProfile) -> dict[str, LLMConfigParameter]:
+        """Build a dict of sub-agent type to LLMConfigParameter based on profile tools."""
+        enabled_types: set[str] = set()
+        for tool in profile.tools:
+            sub_profile = get_sub_agent_profile_by_tool(tool.name)
+            if sub_profile is not None:
+                enabled_types.add(sub_profile.name)
         return {
             sub_agent_type: client.get_llm_config()
             for sub_agent_type, client in self._llm_clients.sub_clients.items()
-            if sub_agent_type in enabled
+            if sub_agent_type in enabled_types
         }
 
     async def ensure_agent(self, session_id: str | None = None) -> Agent:
@@ -145,7 +149,7 @@ class AgentRuntime:
                 session_id=session.id,
                 work_dir=str(session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(profile),
             )
         )
 
@@ -162,27 +166,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,17 +194,19 @@ 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,
                 work_dir=str(agent.session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(agent.profile),
             )
         )
 
@@ -235,7 +230,7 @@ class AgentRuntime:
                 session_id=target_session.id,
                 work_dir=str(target_session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(profile),
             )
         )
 
@@ -419,15 +414,6 @@ class ExecutorContext:
         """Emit an event to the UI display system."""
         await self.event_queue.put(event)
 
-    def _get_sub_agent_models(self) -> dict[str, LLMConfigParameter]:
-        """Build a dict of sub-agent type to LLMConfigParameter."""
-        enabled = self.model_profile_provider.enabled_sub_agent_types()
-        return {
-            sub_agent_type: client.get_llm_config()
-            for sub_agent_type, client in self.llm_clients.sub_clients.items()
-            if sub_agent_type in enabled
-        }
-
     def current_session_id(self) -> str | None:
         """Return the primary active session id, if any.
 
@@ -460,12 +446,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 +497,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 +560,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 +582,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 +693,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 +781,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,
     )