klaude-code 2.5.1__py3-none-any.whl → 2.5.2__py3-none-any.whl

klaude_code/cli/list_model.py

@@ -288,6 +288,14 @@ def _build_models_table(
             name = Text.assemble((prefix, ThemeKey.LINES), (model.model_name, "dim"))
             model_id = Text(model.model_id or "", style="dim")
             params = Text("(unavailable)", style="dim")
+        elif model.disabled:
+            name = Text.assemble(
+                (prefix, ThemeKey.LINES),
+                (model.model_name, "dim strike"),
+                (" (disabled)", "dim"),
+            )
+            model_id = Text(model.model_id or "", style="dim")
+            params = Text(" · ").join(_get_model_params_display(model))
         else:
             # Build role tags for this model
             roles: list[str] = []

klaude_code/cli/main.py

@@ -192,7 +192,7 @@ def main_callback(
                 if raw_model:
                     matches = [
                         m.selector
-                        for m in cfg.iter_model_entries()
+                        for m in cfg.iter_model_entries(only_available=True, include_disabled=False)
                         if (m.model_id or "").strip().lower() == raw_model.lower()
                     ]
                     if len(matches) == 1:

klaude_code/config/assets/builtin_config.yaml

@@ -96,7 +96,6 @@ provider_list:
   - model_name: opus
     model_id: anthropic/claude-4.5-opus
     context_limit: 200000
-    verbosity: high
     thinking:
       type: enabled
       budget_tokens: 2048
@@ -222,7 +221,6 @@ provider_list:
   - model_name: opus
     model_id: claude-opus-4-5-20251101
     context_limit: 200000
-    verbosity: high
     thinking:
       type: enabled
       budget_tokens: 2048

klaude_code/config/config.py

@@ -332,11 +332,12 @@ class Config(BaseModel):
 
         raise ValueError(f"Unknown model: {model_name}")
 
-    def iter_model_entries(self, only_available: bool = False) -> list[ModelEntry]:
+    def iter_model_entries(self, only_available: bool = False, include_disabled: bool = True) -> list[ModelEntry]:
         """Return all model entries with their provider names.
 
         Args:
             only_available: If True, only return models from providers with valid API keys.
+            include_disabled: If False, exclude models with disabled=True.
         """
         return [
             ModelEntry(
@@ -347,25 +348,26 @@ class Config(BaseModel):
             for provider in self.provider_list
             if not only_available or not provider.is_api_key_missing()
             for model in provider.model_list
+            if include_disabled or not model.disabled
         ]
 
     def has_available_image_model(self) -> bool:
         """Check if any image generation model is available."""
-        for entry in self.iter_model_entries(only_available=True):
+        for entry in self.iter_model_entries(only_available=True, include_disabled=False):
             if entry.modalities and "image" in entry.modalities:
                 return True
         return False
 
     def get_first_available_nano_banana_model(self) -> str | None:
         """Get the first available nano-banana model, or None."""
-        for entry in self.iter_model_entries(only_available=True):
+        for entry in self.iter_model_entries(only_available=True, include_disabled=False):
             if "nano-banana" in entry.model_name:
                 return entry.model_name
         return None
 
     def get_first_available_image_model(self) -> str | None:
         """Get the first available image generation model, or None."""
-        for entry in self.iter_model_entries(only_available=True):
+        for entry in self.iter_model_entries(only_available=True, include_disabled=False):
             if entry.modalities and "image" in entry.modalities:
                 return entry.model_name
         return None
@@ -435,11 +437,26 @@ def _get_builtin_config() -> Config:
     return Config(provider_list=providers, sub_agent_models=sub_agent_models)
 
 
+def _merge_model(builtin: ModelConfig, user: ModelConfig) -> ModelConfig:
+    """Merge user model config with builtin model config.
+
+    Strategy: user values take precedence if explicitly set (not default).
+    This allows users to override specific fields (e.g., disabled=true)
+    without losing other builtin settings (e.g., model_id, max_tokens).
+    """
+    merged_data = builtin.model_dump()
+    user_data = user.model_dump(exclude_defaults=True, exclude={"model_name"})
+    for key, value in user_data.items():
+        if value is not None:
+            merged_data[key] = value
+    return ModelConfig.model_validate(merged_data)
+
+
 def _merge_provider(builtin: ProviderConfig, user: UserProviderConfig) -> ProviderConfig:
     """Merge user provider config with builtin provider config.
 
     Strategy:
-    - model_list: merge by model_name, user models override builtin models with same name
+    - model_list: merge by model_name, user model fields override builtin fields
     - Other fields (api_key, base_url, etc.): user config takes precedence if set
     """
     # Merge model_list: builtin first, then user overrides/appends
@@ -447,7 +464,12 @@ def _merge_provider(builtin: ProviderConfig, user: UserProviderConfig) -> Provid
     for m in builtin.model_list:
         merged_models[m.model_name] = m
     for m in user.model_list:
-        merged_models[m.model_name] = m
+        if m.model_name in merged_models:
+            # Merge with builtin model
+            merged_models[m.model_name] = _merge_model(merged_models[m.model_name], m)
+        else:
+            # New model from user
+            merged_models[m.model_name] = m
 
     # For other fields, use user values if explicitly set, otherwise use builtin
     # We check if user explicitly provided a value by comparing to defaults
@@ -578,7 +600,8 @@ def _load_config_cached() -> Config:
 def load_config() -> Config:
     """Load config from disk (builtin + user merged).
 
-    Always returns a valid Config. Use config.iter_model_entries(only_available=True)
+    Always returns a valid Config. Use
+    ``config.iter_model_entries(only_available=True, include_disabled=False)``
     to check if any models are actually usable.
     """
     try:

klaude_code/config/model_matcher.py

@@ -48,9 +48,9 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
     """
     config = load_config()
 
-    # Only show models from providers with valid API keys
+    # Only show models from providers with valid API keys, exclude disabled models
     models: list[ModelEntry] = sorted(
-        config.iter_model_entries(only_available=True),
+        config.iter_model_entries(only_available=True, include_disabled=False),
         key=lambda m: (m.provider.lower(), m.model_name.lower()),
     )
 

klaude_code/config/sub_agent_model_helper.py

@@ -180,7 +180,7 @@ class SubAgentModelHelper:
         - Returns all available models
         """
         profile = get_sub_agent_profile(sub_agent_type)
-        all_models = self._config.iter_model_entries(only_available=True)
+        all_models = self._config.iter_model_entries(only_available=True, include_disabled=False)
 
         if profile.availability_requirement == AVAILABILITY_IMAGE_MODEL:
             return [m for m in all_models if m.modalities and "image" in m.modalities]

klaude_code/core/agent_profile.py

@@ -48,6 +48,7 @@ COMMAND_DESCRIPTIONS: dict[str, str] = {
     "fd": "simple and fast alternative to find",
     "tree": "directory listing as a tree",
     "sg": "ast-grep - AST-aware code search",
+    "jq": "command-line JSON processor",
     "jj": "jujutsu - Git-compatible version control system",
 }
 

klaude_code/core/executor.py

@@ -18,6 +18,7 @@ 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.loaded_skills import get_loaded_skill_names_by_location
 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
@@ -136,6 +137,7 @@ class AgentRuntime:
                 session_id=session.id,
                 work_dir=str(session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
+                loaded_skills=get_loaded_skill_names_by_location(),
             )
         )
 
@@ -192,6 +194,7 @@ class AgentRuntime:
                 session_id=agent.session.id,
                 work_dir=str(agent.session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
+                loaded_skills=get_loaded_skill_names_by_location(),
             )
         )
 
@@ -215,6 +218,7 @@ class AgentRuntime:
                 session_id=target_session.id,
                 work_dir=str(target_session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
+                loaded_skills=get_loaded_skill_names_by_location(),
             )
         )
 

klaude_code/core/loaded_skills.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+
+def get_loaded_skill_names_by_location() -> dict[str, list[str]]:
+    """Return loaded skill names grouped by location.
+
+    The UI should not import the skill system directly. Core can expose a
+    lightweight summary suitable for WelcomeEvent rendering.
+    """
+
+    try:
+        # Import lazily to keep startup overhead minimal and avoid unnecessary
+        # coupling at module import time.
+        from klaude_code.skill.manager import get_available_skills
+    except Exception:
+        return {}
+
+    result: dict[str, list[str]] = {"user": [], "project": [], "system": []}
+    try:
+        for name, _desc, location in get_available_skills():
+            if location == "user":
+                result["user"].append(name)
+            elif location == "project":
+                result["project"].append(name)
+            elif location == "system":
+                result["system"].append(name)
+    except Exception:
+        return {}
+
+    if not result["user"] and not result["project"] and not result["system"]:
+        return {}
+
+    result["user"].sort()
+    result["project"].sort()
+    result["system"].sort()
+    return result

klaude_code/core/tool/context.py

@@ -89,7 +89,5 @@ class ToolContext:
     def with_record_sub_agent_session_id(self, callback: Callable[[str], None] | None) -> ToolContext:
         return replace(self, record_sub_agent_session_id=callback)
 
-    def with_register_sub_agent_metadata_getter(
-        self, callback: Callable[[GetMetadataFn], None] | None
-    ) -> ToolContext:
+    def with_register_sub_agent_metadata_getter(self, callback: Callable[[GetMetadataFn], None] | None) -> ToolContext:
         return replace(self, register_sub_agent_metadata_getter=callback)

klaude_code/core/turn.py

@@ -339,12 +339,6 @@ class TurnExecutor:
                             )
                     case message.StreamErrorItem() as msg:
                         turn_result.stream_error = msg
-                        log_debug(
-                            "[StreamError]",
-                            msg.error,
-                            style="red",
-                            debug_type=DebugType.RESPONSE,
-                        )
                     case message.ToolCallStartDelta() as msg:
                         if thinking_active:
                             thinking_active = False

klaude_code/llm/anthropic/client.py

@@ -282,8 +282,6 @@ async def parse_anthropic_stream(
                         max_tokens=param.max_tokens,
                     )
                 )
-                metadata_tracker.set_model_name(str(param.model_id))
-                metadata_tracker.set_response_id(state.response_id)
                 raw_stop_reason = getattr(event, "stop_reason", None)
                 if isinstance(raw_stop_reason, str):
                     state.stop_reason = _map_anthropic_stop_reason(raw_stop_reason)
@@ -293,6 +291,8 @@ async def parse_anthropic_stream(
     parts = state.flush_all()
     if parts:
         metadata_tracker.record_token()
+    metadata_tracker.set_model_name(str(param.model_id))
+    metadata_tracker.set_response_id(state.response_id)
     metadata = metadata_tracker.finalize()
     yield message.AssistantMessage(
         parts=parts,
@@ -322,15 +322,27 @@ class AnthropicLLMStream(LLMStreamABC):
         return self._iterate()
 
     async def _iterate(self) -> AsyncGenerator[message.LLMStreamItem]:
-        async for item in parse_anthropic_stream(
-            self._stream,
-            self._param,
-            self._metadata_tracker,
-            self._state,
-        ):
-            if isinstance(item, message.AssistantMessage):
-                self._completed = True
-            yield item
+        try:
+            async for item in parse_anthropic_stream(
+                self._stream,
+                self._param,
+                self._metadata_tracker,
+                self._state,
+            ):
+                if isinstance(item, message.AssistantMessage):
+                    self._completed = True
+                yield item
+        except (anthropic.AnthropicError, httpx.HTTPError) as e:
+            yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            self._metadata_tracker.set_model_name(str(self._param.model_id))
+            self._metadata_tracker.set_response_id(self._state.response_id)
+            metadata = self._metadata_tracker.finalize()
+            yield message.AssistantMessage(
+                parts=[],
+                response_id=self._state.response_id,
+                usage=metadata,
+                stop_reason="error",
+            )
 
     def get_partial_message(self) -> message.AssistantMessage | None:
         if self._completed:

klaude_code/protocol/events/system.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pydantic import Field
+
 from klaude_code.protocol import llm_param
 from klaude_code.protocol.events.chat import DeveloperMessageEvent, UserMessageEvent
 from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnStartEvent
@@ -14,6 +16,7 @@ class WelcomeEvent(Event):
     work_dir: str
     llm_config: llm_param.LLMConfigParameter
     show_klaude_code_info: bool = True
+    loaded_skills: dict[str, list[str]] = Field(default_factory=dict)
 
 
 class ErrorEvent(Event):

klaude_code/protocol/llm_param.py

@@ -120,6 +120,7 @@ class LLMConfigProviderParameter(BaseModel):
 
 class LLMConfigModelParameter(BaseModel):
     model_id: str | None = None
+    disabled: bool = False
     temperature: float | None = None
     max_tokens: int | None = None
     context_limit: int | None = None