klaude-code 2.2.0__tar.gz → 2.3.0__tar.gz

{klaude_code-2.2.0 → klaude_code-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.2.0
+Version: 2.3.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-2.2.0 → klaude_code-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.2.0"
+version = "2.3.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -40,6 +40,7 @@ dev = [
     "pyright>=1.1.407",
     "pytest>=8.4.1",
     "pytest-cov>=7.0.0",
+    "ty>=0.0.8",
 ]
 
 
@@ -74,6 +75,15 @@ exclude = [".venv/"]
 root = "."
 extraPaths = ["src"]
 
+[tool.ty.environment]
+python-version = "3.13"
+
+[tool.ty.src]
+include = [
+    "src",
+    "tests",
+]
+
 [tool.importlinter]
 root_packages = ["klaude_code"]
 include_external_packages = false

{klaude_code-2.2.0 → klaude_code-2.3.0}/src/klaude_code/app/runtime.py

@@ -55,24 +55,11 @@ async def initialize_app_components(
 
     config = load_config()
 
-    if init_config.banana:
-        # Banana mode is strict: it requires the built-in Nano Banana image model to be available.
-        required_model = "nano-banana-pro@or"
-        available = {m.model_name for m in config.iter_model_entries(only_available=True)}
-        if required_model not in available:
-            log(
-                (
-                    f"Error: --banana requires model '{required_model}', but it is not available in the current environment",
-                    "red",
-                )
-            )
-            log(("Hint: set OPENROUTER_API_KEY (Nano Banana Pro is configured via OpenRouter by default)", "yellow"))
-            raise typer.Exit(2)
-
     try:
         llm_clients = build_llm_clients(
             config,
             model_override=init_config.model,
+            skip_sub_agents=init_config.vanilla or init_config.banana,
         )
     except ValueError as exc:
         if init_config.model:
@@ -92,7 +79,7 @@ async def initialize_app_components(
     elif init_config.vanilla:
         model_profile_provider = VanillaModelProfileProvider()
     else:
-        model_profile_provider = DefaultModelProfileProvider()
+        model_profile_provider = DefaultModelProfileProvider(config=config)
 
     event_queue: asyncio.Queue[events.Event] = asyncio.Queue()
 

{klaude_code-2.2.0 → klaude_code-2.3.0}/src/klaude_code/cli/list_model.py

@@ -243,18 +243,34 @@ def _build_provider_info_panel(provider: ProviderConfig, available: bool) -> Quo
 
 
 def _build_models_table(
-    provider: ProviderConfig, main_model: str | None, sub_agent_models: dict[str, str] | None = None
+    provider: ProviderConfig,
+    config: Config,
 ) -> Table:
     """Build a table for models under a provider."""
     provider_available = not provider.is_api_key_missing()
 
+    def _resolve_selector(value: str | None) -> str | None:
+        if not value:
+            return None
+        try:
+            resolved = config.resolve_model_location_prefer_available(value) or config.resolve_model_location(value)
+        except ValueError:
+            return None
+        if resolved is None:
+            return None
+        return f"{resolved[0]}@{resolved[1]}"
+
+    default_selector = _resolve_selector(config.main_model)
+
     # Build reverse mapping: model_name -> list of agent roles using it
     model_to_agents: dict[str, list[str]] = {}
-    if sub_agent_models:
-        for agent_role, model_name in sub_agent_models.items():
-            if model_name not in model_to_agents:
-                model_to_agents[model_name] = []
-            model_to_agents[model_name].append(agent_role)
+    for agent_role, model_name in (config.sub_agent_models or {}).items():
+        selector = _resolve_selector(model_name)
+        if selector is None:
+            continue
+        if selector not in model_to_agents:
+            model_to_agents[selector] = []
+        model_to_agents[selector].append(agent_role)
 
     models_table = Table.grid(
         padding=(0, 2),
@@ -275,10 +291,11 @@ def _build_models_table(
         else:
             # Build role tags for this model
             roles: list[str] = []
-            if model.model_name == main_model:
+            selector = f"{model.model_name}@{provider.provider_name}"
+            if selector == default_selector:
                 roles.append("default")
-            if model.model_name in model_to_agents:
-                roles.extend(role.lower() for role in model_to_agents[model.model_name])
+            if selector in model_to_agents:
+                roles.extend(role.lower() for role in model_to_agents[selector])
 
             if roles:
                 name = Text.assemble(
@@ -350,6 +367,6 @@ def display_models_and_providers(config: Config, *, show_all: bool = False):
         console.print()
 
         # Models table for this provider
-        models_table = _build_models_table(provider, config.main_model, config.sub_agent_models)
+        models_table = _build_models_table(provider, config)
         console.print(models_table)
         console.print("\n")

{klaude_code-2.2.0 → klaude_code-2.3.0}/src/klaude_code/cli/main.py

@@ -124,18 +124,28 @@ def main_callback(
             raise typer.Exit(2)
 
         from klaude_code.app.runtime import AppInitConfig
-        from klaude_code.tui.command.model_select import select_model_interactive
+        from klaude_code.tui.command.model_select import ModelSelectStatus, select_model_interactive
         from klaude_code.tui.runner import run_interactive
 
         update_terminal_title()
 
         chosen_model = model
         if banana:
-            # Banana mode always uses the built-in Nano Banana Pro image model.
-            chosen_model = "nano-banana-pro@or"
+            keywords = ["gemini-3-pro-image", "gemini-2.5-flash-image"]
+            model_result = select_model_interactive(keywords=keywords)
+            if model_result.status == ModelSelectStatus.SELECTED and model_result.model is not None:
+                chosen_model = model_result.model
+            elif model_result.status == ModelSelectStatus.CANCELLED:
+                return
+            else:
+                log(("Error: no available nano-banana model", "red"))
+                log(("Hint: set OPENROUTER_API_KEY or GOOGLE_API_KEY to enable nano-banana models", "yellow"))
+                raise typer.Exit(2)
         elif model or select_model:
-            chosen_model = select_model_interactive(preferred=model)
-            if chosen_model is None:
+            model_result = select_model_interactive(preferred=model)
+            if model_result.status == ModelSelectStatus.SELECTED and model_result.model is not None:
+                chosen_model = model_result.model
+            else:
                 return
 
         # Resolve session id before entering asyncio loop
@@ -162,7 +172,12 @@ def main_callback(
             cfg = load_config()
 
             if session_meta.model_config_name:
-                if any(m.model_name == session_meta.model_config_name for m in cfg.iter_model_entries()):
+                try:
+                    model_is_known = cfg.has_model_config_name(session_meta.model_config_name)
+                except ValueError:
+                    model_is_known = False
+
+                if model_is_known:
                     chosen_model = session_meta.model_config_name
                 else:
                     log(
@@ -176,7 +191,7 @@ def main_callback(
                 raw_model = session_meta.model_name.strip()
                 if raw_model:
                     matches = [
-                        m.model_name
+                        m.selector
                         for m in cfg.iter_model_entries()
                         if (m.model_params.model or "").strip().lower() == raw_model.lower()
                     ]
@@ -189,9 +204,10 @@ def main_callback(
 
             cfg = load_config()
             if cfg.main_model is None:
-                chosen_model = select_model_interactive()
-                if chosen_model is None:
+                model_result = select_model_interactive()
+                if model_result.status != ModelSelectStatus.SELECTED or model_result.model is None:
                     raise typer.Exit(1)
+                chosen_model = model_result.model
                 # Save the selection as default
                 cfg.main_model = chosen_model
                 from klaude_code.config.config import config_path

{klaude_code-2.2.0 → klaude_code-2.3.0}/src/klaude_code/config/assets/builtin_config.yaml

@@ -7,7 +7,7 @@ provider_list:
   protocol: anthropic
   api_key: ${ANTHROPIC_API_KEY}
   model_list:
-  - model_name: sonnet@ant
+  - model_name: sonnet
     model_params:
       model: claude-sonnet-4-5-20250929
       context_limit: 200000
@@ -18,7 +18,7 @@ provider_list:
         output: 15.0
         cache_read: 0.3
         cache_write: 3.75
-  - model_name: opus@ant
+  - model_name: opus
     model_params:
       model: claude-opus-4-5-20251101
       context_limit: 200000
@@ -187,10 +187,10 @@ provider_list:
         input: 0.5
         output: 3.0
         cache_read: 0.05
-  - model_name: nano-banana-pro@or
+  - model_name: nano-banana-pro
     model_params:
       model: google/gemini-3-pro-image-preview
-      context_limit: 1048576
+      context_limit: 66000
       modalities:
       - image
       - text
@@ -199,6 +199,18 @@ provider_list:
         output: 12
         cache_read: 0.2
         image: 120
+  - model_name: nano-banana
+    model_params:
+      model: google/gemini-2.5-flash-image
+      context_limit: 33000
+      modalities:
+      - image
+      - text
+      cost:
+        input: 0.3
+        output: 2.5
+        cache_read: 0.03
+        image: 30
   - model_name: grok
     model_params:
       model: x-ai/grok-4.1-fast
@@ -234,7 +246,7 @@ provider_list:
   protocol: google
   api_key: ${GOOGLE_API_KEY}
   model_list:
-  - model_name: gemini-pro@google
+  - model_name: gemini-pro
     model_params:
       model: gemini-3-pro-preview
       context_limit: 1048576
@@ -242,7 +254,7 @@ provider_list:
         input: 2.0
         output: 12.0
         cache_read: 0.2
-  - model_name: gemini-flash@google
+  - model_name: gemini-flash
     model_params:
       model: gemini-3-flash-preview
       context_limit: 1048576
@@ -250,10 +262,10 @@ provider_list:
         input: 0.5
         output: 3.0
         cache_read: 0.05
-  - model_name: nano-banana-pro@google
+  - model_name: nano-banana-pro
     model_params:
       model: gemini-3-pro-image-preview
-      context_limit: 1048576
+      context_limit: 66000
       modalities:
       - image
       - text
@@ -269,7 +281,7 @@ provider_list:
   aws_secret_key: ${AWS_SECRET_ACCESS_KEY}
   aws_region: ${AWS_REGION}
   model_list:
-  - model_name: sonnet@bedrock
+  - model_name: sonnet
     model_params:
       model: us.anthropic.claude-sonnet-4-5-20250929-v1:0
       context_limit: 200000
@@ -302,7 +314,7 @@ provider_list:
   api_key: ${MOONSHOT_API_KEY}
   base_url: https://api.moonshot.cn/anthropic
   model_list:
-  - model_name: kimi@moonshot
+  - model_name: kimi
     model_params:
       model: kimi-k2-thinking
       context_limit: 262144
@@ -318,7 +330,7 @@ provider_list:
 - provider_name: claude-max
   protocol: claude_oauth
   model_list:
-  - model_name: sonnet@claude-max
+  - model_name: sonnet
     model_params:
       model: claude-sonnet-4-5-20250929
       context_limit: 200000
@@ -327,7 +339,7 @@ provider_list:
         output: 15.0
         cache_read: 0.3
         cache_write: 3.75
-  - model_name: opus@claude-max
+  - model_name: opus
     model_params:
       model: claude-opus-4-5-20251101
       context_limit: 200000
@@ -340,7 +352,7 @@ provider_list:
         output: 25.0
         cache_read: 0.5
         cache_write: 6.25
-  - model_name: haiku@claude-max
+  - model_name: haiku
     model_params:
       model: claude-haiku-4-5-20251001
       context_limit: 200000
@@ -364,6 +376,3 @@ provider_list:
         input: 1.75
         output: 14.0
         cache_read: 0.17
-
-sub_agent_models:
-  ImageGen: nano-banana-pro@or

{klaude_code-2.2.0 → klaude_code-2.3.0}/src/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-2.2.0 → klaude_code-2.3.0}/src/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)