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

klaude_code/config/config.py

@@ -140,6 +140,16 @@ class ModelEntry(BaseModel):
     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):
     """User configuration (what gets saved to disk)."""
@@ -191,8 +201,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 +311,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_params.model_dump(),
+                )
 
         raise ValueError(f"Unknown model: {model_name}")
 
@@ -235,6 +347,27 @@ class Config(BaseModel):
             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.model_params.modalities and "image" in entry.model_params.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.model_params.modalities and "image" in entry.model_params.modalities:
+                return entry.model_name
+        return None
+
     async def save(self) -> None:
         """Save user config to file (excludes builtin providers).
 
@@ -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

@@ -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.model_name.lower(), m.provider.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_params.model)
         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_params.model 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,24 +108,30 @@ 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)
+                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 "")
             ]
             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)
+                    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 "")
                 ]
                 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.
@@ -116,10 +139,12 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
         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_params.model 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.model_params.modalities and "image" in m.model_params.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/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
@@ -155,7 +155,7 @@ MARKDOWN_RIGHT_MARGIN = 2  # Right margin (columns) for markdown rendering
 STATUS_HINT_TEXT = " (esc to interrupt)"  # Status hint text shown after spinner
 
 # Spinner status texts
-STATUS_WAITING_TEXT = "Awaiting …"
+STATUS_WAITING_TEXT = "Connecting …"
 STATUS_THINKING_TEXT = "Reasoning …"
 STATUS_COMPOSING_TEXT = "Generating"
 

klaude_code/core/agent_profile.py

@@ -7,8 +7,12 @@ from dataclasses import dataclass
 from functools import cache
 from importlib.resources import files
 from pathlib import Path
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
 
+if TYPE_CHECKING:
+    from klaude_code.config.config import Config
+
+from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
 from klaude_code.core.reminders import (
     at_file_reader_reminder,
     empty_todo_reminder,
@@ -23,7 +27,7 @@ from klaude_code.core.tool.report_back_tool import ReportBackTool
 from klaude_code.core.tool.tool_registry import get_tool_schemas
 from klaude_code.llm import LLMClientABC
 from klaude_code.protocol import llm_param, message, tools
-from klaude_code.protocol.sub_agent import get_sub_agent_profile, sub_agent_tool_names
+from klaude_code.protocol.sub_agent import get_sub_agent_profile
 from klaude_code.session import Session
 
 type Reminder = Callable[[Session], Awaitable[message.DeveloperMessage | None]]
@@ -58,6 +62,9 @@ PROMPT_FILES: dict[str, str] = {
 }
 
 
+NANO_BANANA_SYSTEM_PROMPT_PATH = "prompts/prompt-nano-banana.md"
+
+
 STRUCTURED_OUTPUT_PROMPT = """\
 
 # Structured Output
@@ -166,12 +173,14 @@ def load_system_prompt(
 def load_agent_tools(
     model_name: str,
     sub_agent_type: tools.SubAgentType | None = None,
+    config: Config | None = None,
 ) -> list[llm_param.ToolSchema]:
     """Get tools for an agent based on model and agent type.
 
     Args:
         model_name: The model name.
         sub_agent_type: If None, returns main agent tools. Otherwise returns sub-agent tools.
+        config: Config for checking sub-agent availability (e.g., image model availability).
     """
 
     if sub_agent_type is not None:
@@ -180,13 +189,20 @@ def load_agent_tools(
 
     # Main agent tools
     if "gpt-5" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
+        tool_names: list[str] = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
     elif "gemini-3" in model_name:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
-    tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
+    if config is not None:
+        helper = SubAgentModelHelper(config)
+        tool_names.extend(helper.get_enabled_sub_agent_tool_names())
+    else:
+        from klaude_code.protocol.sub_agent import sub_agent_tool_names
+
+        tool_names.extend(sub_agent_tool_names(enabled_only=True))
+
     tool_names.extend([tools.MERMAID])
     # tool_names.extend([tools.MEMORY])
     return get_tool_schemas(tool_names)
@@ -246,10 +262,17 @@ 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."""
 
+    def __init__(self, config: Config | None = None) -> None:
+        self._config = config
+
     def build_profile(
         self,
         llm_client: LLMClientABC,
@@ -261,13 +284,25 @@ class DefaultModelProfileProvider(ModelProfileProvider):
         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),
+            tools=load_agent_tools(model_name, sub_agent_type, config=self._config),
             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."""
@@ -289,3 +324,34 @@ class VanillaModelProfileProvider(ModelProfileProvider):
         if output_schema:
             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.
+
+    This mode uses a dedicated system prompt and strips all tools/reminders.
+    """
+
+    def build_profile(
+        self,
+        llm_client: LLMClientABC,
+        sub_agent_type: tools.SubAgentType | None = None,
+        *,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentProfile:
+        del sub_agent_type
+        profile = AgentProfile(
+            llm_client=llm_client,
+            system_prompt=_load_prompt_by_path(NANO_BANANA_SYSTEM_PROMPT_PATH),
+            tools=[],
+            reminders=[],
+        )
+        if output_schema:
+            return with_structured_output(profile, output_schema)
+        return profile
+
+    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
+        return set()