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

klaude_code/config/config.py

@@ -58,9 +58,10 @@ config_path = Path.home() / ".klaude" / "klaude-config.yaml"
 example_config_path = Path.home() / ".klaude" / "klaude-config.example.yaml"
 
 
-class ModelConfig(BaseModel):
+class ModelConfig(llm_param.LLMConfigModelParameter):
+    """Model configuration that flattens LLMConfigModelParameter fields."""
+
     model_name: str
-    model_params: llm_param.LLMConfigModelParameter
 
 
 class ProviderConfig(llm_param.LLMConfigProviderParameter):
@@ -135,10 +136,21 @@ class UserProviderConfig(BaseModel):
     model_list: list[ModelConfig] = Field(default_factory=lambda: [])
 
 
-class ModelEntry(BaseModel):
+class ModelEntry(llm_param.LLMConfigModelParameter):
+    """Model entry with provider info, flattens LLMConfigModelParameter fields."""
+
     model_name: str
     provider: str
-    model_params: llm_param.LLMConfigModelParameter
+
+    @property
+    def selector(self) -> str:
+        """Return a provider-qualified model selector.
+
+        This selector can be persisted in user config (e.g. ``sonnet@openrouter``)
+        and later resolved via :meth:`Config.get_model_config`.
+        """
+
+        return f"{self.model_name}@{self.provider}"
 
 
 class UserConfig(BaseModel):
@@ -191,8 +203,103 @@ class Config(BaseModel):
         """Set the user config reference for saving."""
         object.__setattr__(self, "_user_config", user_config)
 
+    @classmethod
+    def _split_model_selector(cls, model_selector: str) -> tuple[str, str | None]:
+        """Split a model selector into (model_name, provider_name).
+
+        Supported forms:
+        - ``sonnet``: unqualified; caller should pick the first matching provider.
+        - ``sonnet@openrouter``: provider-qualified.
+
+        Note: the provider segment is normalized for backwards compatibility.
+        """
+
+        trimmed = model_selector.strip()
+        if "@" not in trimmed:
+            return trimmed, None
+
+        base, provider = trimmed.rsplit("@", 1)
+        base = base.strip()
+        provider = provider.strip()
+        if not base or not provider:
+            raise ValueError(f"Invalid model selector: {model_selector!r}")
+        return base, provider
+
+    def has_model_config_name(self, model_selector: str) -> bool:
+        """Return True if the selector points to a configured model.
+
+        This check is configuration-only: it does not require a valid API key or
+        OAuth login.
+        """
+
+        model_name, provider_name = self._split_model_selector(model_selector)
+        if provider_name is not None:
+            for provider in self.provider_list:
+                if provider.provider_name.casefold() != provider_name.casefold():
+                    continue
+                return any(m.model_name == model_name for m in provider.model_list)
+            return False
+
+        return any(any(m.model_name == model_name for m in provider.model_list) for provider in self.provider_list)
+
+    def resolve_model_location(self, model_selector: str) -> tuple[str, str] | None:
+        """Resolve a selector to (model_name, provider_name), without auth checks.
+
+        - If the selector is provider-qualified, returns that provider.
+        - If unqualified, returns the first provider that defines the model.
+        """
+
+        model_name, provider_name = self._split_model_selector(model_selector)
+        if provider_name is not None:
+            for provider in self.provider_list:
+                if provider.provider_name.casefold() != provider_name.casefold():
+                    continue
+                if any(m.model_name == model_name for m in provider.model_list):
+                    return model_name, provider.provider_name
+            return None
+
+        for provider in self.provider_list:
+            if any(m.model_name == model_name for m in provider.model_list):
+                return model_name, provider.provider_name
+        return None
+
+    def resolve_model_location_prefer_available(self, model_selector: str) -> tuple[str, str] | None:
+        """Resolve a selector to (model_name, provider_name), preferring usable providers.
+
+        This uses the same availability logic as :meth:`get_model_config` (API-key
+        presence for non-OAuth protocols).
+        """
+
+        requested_model, requested_provider = self._split_model_selector(model_selector)
+
+        for provider in self.provider_list:
+            if requested_provider is not None and provider.provider_name.casefold() != requested_provider.casefold():
+                continue
+
+            api_key = provider.get_resolved_api_key()
+            if (
+                provider.protocol
+                not in {
+                    llm_param.LLMClientProtocol.CODEX_OAUTH,
+                    llm_param.LLMClientProtocol.CLAUDE_OAUTH,
+                    llm_param.LLMClientProtocol.BEDROCK,
+                }
+                and not api_key
+            ):
+                continue
+
+            if any(m.model_name == requested_model for m in provider.model_list):
+                return requested_model, provider.provider_name
+
+        return None
+
     def get_model_config(self, model_name: str) -> llm_param.LLMConfigParameter:
+        requested_model, requested_provider = self._split_model_selector(model_name)
+
         for provider in self.provider_list:
+            if requested_provider is not None and provider.provider_name.casefold() != requested_provider.casefold():
+                continue
+
             # Resolve ${ENV_VAR} syntax for api_key
             api_key = provider.get_resolved_api_key()
 
@@ -206,15 +313,22 @@ class Config(BaseModel):
                 }
                 and not api_key
             ):
+                # When provider is explicitly requested, fail fast with a clearer error.
+                if requested_provider is not None:
+                    raise ValueError(
+                        f"Provider '{provider.provider_name}' is not available (missing API key) for: {model_name}"
+                    )
                 continue
+
             for model in provider.model_list:
-                if model.model_name == model_name:
-                    provider_dump = provider.model_dump(exclude={"model_list"})
-                    provider_dump["api_key"] = api_key
-                    return llm_param.LLMConfigParameter(
-                        **provider_dump,
-                        **model.model_params.model_dump(),
-                    )
+                if model.model_name != requested_model:
+                    continue
+                provider_dump = provider.model_dump(exclude={"model_list"})
+                provider_dump["api_key"] = api_key
+                return llm_param.LLMConfigParameter(
+                    **provider_dump,
+                    **model.model_dump(exclude={"model_name"}),
+                )
 
         raise ValueError(f"Unknown model: {model_name}")
 
@@ -228,13 +342,34 @@ class Config(BaseModel):
             ModelEntry(
                 model_name=model.model_name,
                 provider=provider.provider_name,
-                model_params=model.model_params,
+                **model.model_dump(exclude={"model_name"}),
             )
             for provider in self.provider_list
             if not only_available or not provider.is_api_key_missing()
             for model in provider.model_list
         ]
 
+    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):
+            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):
+            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):
+            if entry.modalities and "image" in entry.modalities:
+                return entry.model_name
+        return None
+
     async def save(self) -> None:
         """Save user config to file (excludes builtin providers).
 
@@ -276,15 +411,13 @@ def get_example_config() -> UserConfig:
                 model_list=[
                     ModelConfig(
                         model_name="my-model",
-                        model_params=llm_param.LLMConfigModelParameter(
-                            model="model-id-from-provider",
-                            max_tokens=16000,
-                            context_limit=200000,
-                            cost=llm_param.Cost(
-                                input=1,
-                                output=10,
-                                cache_read=0.1,
-                            ),
+                        model_id="model-id-from-provider",
+                        max_tokens=16000,
+                        context_limit=200000,
+                        cost=llm_param.Cost(
+                            input=1,
+                            output=10,
+                            cache_read=0.1,
                         ),
                     ),
                 ],
@@ -418,6 +551,10 @@ def create_example_config() -> bool:
     header = "# Example configuration for klaude-code\n"
     header += "# Copy this file to klaude-config.yaml and modify as needed.\n"
     header += "# Run `klaude list` to see available models.\n"
+    header += "# Tip: you can pick a provider explicitly with `model@provider` (e.g. `sonnet@openrouter`).\n"
+    header += (
+        "# If you omit `@provider` (e.g. `sonnet`), klaude picks the first configured provider with credentials.\n"
+    )
     header += "#\n"
     header += "# Built-in providers (anthropic, openai, openrouter, deepseek) are available automatically.\n"
     header += "# Just set the corresponding API key environment variable to use them.\n\n"

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

@@ -50,7 +50,8 @@ 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()
+        config.iter_model_entries(only_available=True),
+        key=lambda m: (m.provider.lower(), m.model_name.lower()),
     )
 
     if not models:
@@ -62,26 +63,42 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
             error_message="No models available",
         )
 
-    names: list[str] = [m.model_name for m in models]
+    selectors: list[str] = [m.selector for m in models]
 
     # Try to match preferred model name
     filter_hint = preferred
     if preferred and preferred.strip():
         preferred = preferred.strip()
-        # Exact match
-        if preferred in names:
+
+        # Exact match on selector (e.g. sonnet@openrouter)
+        if preferred in selectors:
             return ModelMatchResult(matched_model=preferred, filtered_models=models, filter_hint=None)
 
+        # Exact match on base model name (e.g. sonnet)
+        exact_base_matches = [m for m in models if m.model_name == preferred]
+        if len(exact_base_matches) == 1:
+            return ModelMatchResult(
+                matched_model=exact_base_matches[0].selector,
+                filtered_models=models,
+                filter_hint=None,
+            )
+        if len(exact_base_matches) > 1:
+            return ModelMatchResult(matched_model=None, filtered_models=exact_base_matches, filter_hint=filter_hint)
+
         preferred_lower = preferred.lower()
-        # Case-insensitive exact match (model_name or model_params.model)
+        # Case-insensitive exact match (selector/model_name/model_id)
         exact_ci_matches = [
             m
             for m in models
-            if preferred_lower == m.model_name.lower() or preferred_lower == (m.model_params.model or "").lower()
+            if preferred_lower == m.selector.lower()
+            or preferred_lower == m.model_name.lower()
+            or preferred_lower == (m.model_id or "").lower()
         ]
         if len(exact_ci_matches) == 1:
             return ModelMatchResult(
-                matched_model=exact_ci_matches[0].model_name, filtered_models=models, filter_hint=None
+                matched_model=exact_ci_matches[0].selector,
+                filtered_models=models,
+                filter_hint=None,
             )
 
         # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
@@ -91,35 +108,43 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
             normalized_matches = [
                 m
                 for m in models
-                if preferred_norm == _normalize_model_key(m.model_name)
-                or preferred_norm == _normalize_model_key(m.model_params.model or "")
+                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_id or "")
             ]
             if len(normalized_matches) == 1:
                 return ModelMatchResult(
-                    matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                    matched_model=normalized_matches[0].selector,
+                    filtered_models=models,
+                    filter_hint=None,
                 )
 
             if not normalized_matches and len(preferred_norm) >= 4:
                 normalized_matches = [
                     m
                     for m in models
-                    if preferred_norm in _normalize_model_key(m.model_name)
-                    or preferred_norm in _normalize_model_key(m.model_params.model or "")
+                    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_id or "")
                 ]
                 if len(normalized_matches) == 1:
                     return ModelMatchResult(
-                        matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                        matched_model=normalized_matches[0].selector,
+                        filtered_models=models,
+                        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.model_name.lower() or preferred_lower in (m.model_params.model or "").lower()
+            if preferred_lower in m.selector.lower()
+            or preferred_lower in m.model_name.lower()
+            or preferred_lower in (m.model_id or "").lower()
         ]
         if len(matches) == 1:
-            return ModelMatchResult(matched_model=matches[0].model_name, filtered_models=models, filter_hint=None)
+            return ModelMatchResult(matched_model=matches[0].selector, filtered_models=models, filter_hint=None)
         if matches:
             # Multiple matches: filter the list for interactive selection
             return ModelMatchResult(matched_model=None, filtered_models=matches, filter_hint=filter_hint)

klaude_code/config/sub_agent_model_helper.py

@@ -0,0 +1,217 @@
+"""Helper for sub-agent model availability and selection logic."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from klaude_code.protocol.sub_agent import (
+    AVAILABILITY_IMAGE_MODEL,
+    SubAgentProfile,
+    get_sub_agent_profile,
+    get_sub_agent_profile_by_tool,
+    iter_sub_agent_profiles,
+    sub_agent_tool_names,
+)
+from klaude_code.protocol.tools import SubAgentType
+
+if TYPE_CHECKING:
+    from klaude_code.config.config import Config, ModelEntry
+
+
+@dataclass
+class SubAgentModelInfo:
+    """Sub-agent and its current model configuration."""
+
+    profile: SubAgentProfile
+    # Explicitly configured model selector (from config), if any.
+    configured_model: str | None
+
+    # Effective model name used by this sub-agent.
+    # - When configured_model is set: equals configured_model.
+    # - When requirement-based default applies (e.g. ImageGen): resolved model.
+    # - When inheriting from main agent: None.
+    effective_model: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class EmptySubAgentModelBehavior:
+    """Human-facing description for an unset (empty) sub-agent model config."""
+
+    # Summary text for UI (kept UI-framework agnostic).
+    description: str
+
+    # Best-effort resolved model name (if any). For ImageGen this is usually the
+    # first available image model; for other sub-agents it's the main model.
+    resolved_model_name: str | None
+
+
+class SubAgentModelHelper:
+    """Centralized logic for sub-agent availability and model selection."""
+
+    def __init__(self, config: Config) -> None:
+        self._config = config
+
+    def check_availability_requirement(self, requirement: str | None) -> bool:
+        """Check if a sub-agent's availability requirement is met.
+
+        Args:
+            requirement: The availability requirement constant (e.g., AVAILABILITY_IMAGE_MODEL).
+
+        Returns:
+            True if the requirement is met or if there's no requirement.
+        """
+        if requirement is None:
+            return True
+
+        if requirement == AVAILABILITY_IMAGE_MODEL:
+            return self._config.has_available_image_model()
+
+        return True
+
+    def resolve_model_for_requirement(self, requirement: str | None) -> str | None:
+        """Resolve the model name for a given availability requirement.
+
+        Args:
+            requirement: The availability requirement constant.
+
+        Returns:
+            The model name if found, None otherwise.
+        """
+        if requirement == AVAILABILITY_IMAGE_MODEL:
+            return self._config.get_first_available_image_model()
+        return None
+
+    def resolve_default_model_override(self, sub_agent_type: str) -> str | None:
+        """Resolve the default model override for a sub-agent when unset.
+
+        Returns:
+            - None for sub-agents that default to inheriting the main agent.
+            - A model name for sub-agents that require a dedicated model (e.g. ImageGen).
+
+        Note: This intentionally ignores any explicit user config; callers use this
+        when they want the *unset* behavior.
+        """
+
+        profile = get_sub_agent_profile(sub_agent_type)
+        if profile.availability_requirement is None:
+            return None
+        return self.resolve_model_for_requirement(profile.availability_requirement)
+
+    def describe_empty_model_config_behavior(
+        self,
+        sub_agent_type: str,
+        *,
+        main_model_name: str,
+    ) -> EmptySubAgentModelBehavior:
+        """Describe what happens when a sub-agent model is not configured.
+
+        Most sub-agents default to inheriting the main model.
+
+        Sub-agents with an availability requirement (e.g. ImageGen) do NOT
+        inherit from the main model; instead they auto-resolve a suitable model
+        (currently: the first available image model).
+        """
+
+        profile = get_sub_agent_profile(sub_agent_type)
+
+        requirement = profile.availability_requirement
+        if requirement is None:
+            return EmptySubAgentModelBehavior(
+                description=f"inherit from main agent: {main_model_name}",
+                resolved_model_name=main_model_name,
+            )
+
+        resolved = self.resolve_model_for_requirement(requirement)
+        if requirement == AVAILABILITY_IMAGE_MODEL:
+            if resolved:
+                return EmptySubAgentModelBehavior(
+                    description=f"auto-select first available image model: {resolved}",
+                    resolved_model_name=resolved,
+                )
+            return EmptySubAgentModelBehavior(
+                description="auto-select first available image model",
+                resolved_model_name=None,
+            )
+
+        if resolved:
+            return EmptySubAgentModelBehavior(
+                description=f"auto-select model for requirement '{requirement}': {resolved}",
+                resolved_model_name=resolved,
+            )
+        return EmptySubAgentModelBehavior(
+            description=f"auto-select model for requirement '{requirement}'",
+            resolved_model_name=None,
+        )
+
+    def get_available_sub_agents(self) -> list[SubAgentModelInfo]:
+        """Return all available sub-agents with their current model config.
+
+        Only returns sub-agents that:
+        1. Are enabled by default
+        2. Have their availability requirements met
+
+        For sub-agents without explicit config, resolves model based on availability_requirement.
+        """
+        result: list[SubAgentModelInfo] = []
+        for profile in iter_sub_agent_profiles(enabled_only=True):
+            if not self.check_availability_requirement(profile.availability_requirement):
+                continue
+            configured_model = self._config.sub_agent_models.get(profile.name)
+            effective_model = configured_model
+            if not effective_model and profile.availability_requirement:
+                effective_model = self.resolve_model_for_requirement(profile.availability_requirement)
+            result.append(
+                SubAgentModelInfo(
+                    profile=profile,
+                    configured_model=configured_model,
+                    effective_model=effective_model,
+                )
+            )
+        return result
+
+    def get_selectable_models(self, sub_agent_type: str) -> list[ModelEntry]:
+        """Return selectable models for a specific sub-agent type.
+
+        For sub-agents with availability_requirement (e.g., ImageGen):
+        - Only returns models matching the requirement (e.g., image models)
+
+        For other sub-agents:
+        - Returns all available models
+        """
+        profile = get_sub_agent_profile(sub_agent_type)
+        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.modalities and "image" in m.modalities]
+
+        return all_models
+
+    def get_enabled_sub_agent_tool_names(self) -> list[str]:
+        """Return sub-agent tool names that should be added to main agent's tool list."""
+        result: list[str] = []
+        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):
+                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] = {}
+        for profile in iter_sub_agent_profiles():
+            model_name = self._config.sub_agent_models.get(profile.name)
+            if not model_name and profile.availability_requirement:
+                model_name = self.resolve_model_for_requirement(profile.availability_requirement)
+            if model_name:
+                result[profile.name] = model_name
+        return result

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

@@ -123,7 +123,7 @@ TAB_EXPAND_WIDTH = 8  # Tab expansion width for text rendering
 DIFF_PREFIX_WIDTH = 4  # Width of line number prefix in diff display
 MAX_DIFF_LINES = 500  # Maximum lines to show in diff output
 INVALID_TOOL_CALL_MAX_LENGTH = 200  # Maximum length for invalid tool call display
-TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 200  # Maximum line length for truncated display
+TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 500  # Maximum line length for truncated display
 TRUNCATE_DISPLAY_MAX_LINES = 4  # Maximum lines for truncated display
 MIN_HIDDEN_LINES_FOR_INDICATOR = 5  # Minimum hidden lines before showing truncation indicator
 SUB_AGENT_RESULT_MAX_LINES = 10  # Maximum lines for sub-agent result display