klaude-code 1.2.26__py3-none-any.whl → 1.2.27__py3-none-any.whl

klaude_code/cli/config_cmd.py

@@ -16,8 +16,6 @@ def list_models() -> None:
     from klaude_code.ui.terminal.color import is_light_terminal_background
 
     config = load_config()
-    if config is None:
-        raise typer.Exit(1)
 
     # Auto-detect theme when not explicitly set in config, to match other CLI entrypoints.
     if config.theme is None:
@@ -60,9 +58,7 @@ def edit_config() -> None:
             editor = "xdg-open"
 
     # Ensure config file exists
-    config = load_config()
-    if config is None:
-        raise typer.Exit(1)
+    load_config()
 
     try:
         if editor == "open -a TextEdit":

klaude_code/cli/list_model.py

@@ -6,44 +6,47 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.config import Config
+from klaude_code.config.config import ModelConfig, ProviderConfig
+from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
 
 
-def _display_codex_status(console: Console) -> None:
-    """Display Codex OAuth login status."""
+def _get_codex_status_elements() -> list[Text]:
+    """Get Codex OAuth login status as Text elements for panel display."""
     from klaude_code.auth.codex.token_manager import CodexTokenManager
 
+    elements: list[Text] = []
     token_manager = CodexTokenManager()
     state = token_manager.get_state()
 
     if state is None:
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Not logged in", ThemeKey.CONFIG_STATUS_ERROR),
                 (" (run 'klaude login codex' to authenticate)", "dim"),
             )
         )
     elif state.is_expired():
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Token expired", ThemeKey.CONFIG_STATUS_ERROR),
                 (" (run 'klaude login codex' to re-authenticate)", "dim"),
             )
         )
     else:
         expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
-        console.print(
+        elements.append(
             Text.assemble(
-                ("Codex Status: ", "bold"),
+                ("Status: ", "bold"),
                 ("Logged in", ThemeKey.CONFIG_STATUS_OK),
                 (f" (account: {state.account_id[:8]}..., expires: {expires_dt.strftime('%Y-%m-%d %H:%M UTC')})", "dim"),
             )
         )
 
-    console.print(
+    elements.append(
         Text.assemble(
             ("Visit ", "dim"),
             (
@@ -53,6 +56,7 @@ def _display_codex_status(console: Console) -> None:
             (" for up-to-date information on rate limits and credits", "dim"),
         )
     )
+    return elements
 
 
 def mask_api_key(api_key: str | None) -> str:
@@ -66,136 +70,179 @@ def mask_api_key(api_key: str | None) -> str:
     return f"{api_key[:6]} … {api_key[-6:]}"
 
 
-def display_models_and_providers(config: Config):
-    """Display models and providers configuration using rich formatting"""
-    themes = get_theme(config.theme)
-    console = Console(theme=themes.app_theme)
+def format_api_key_display(provider: ProviderConfig) -> Text:
+    """Format API key display with warning if env var is not set."""
+    env_var = provider.get_api_key_env_var()
+    resolved_key = provider.get_resolved_api_key()
 
-    # Display providers section
-    providers_table = Table.grid(padding=(0, 1), expand=True)
-    providers_table.add_column(width=2, no_wrap=True)  # Status
-    providers_table.add_column(overflow="fold")  # Name
-    providers_table.add_column(overflow="fold")  # Protocol
-    providers_table.add_column(overflow="fold")  # Base URL
-    providers_table.add_column(overflow="fold")  # API Key
-
-    # Add header
-    providers_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Protocol", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Base URL", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("API Key", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
+    if env_var:
+        # Using ${ENV_VAR} syntax
+        if resolved_key:
+            return Text.assemble(
+                (f"${{{env_var}}} = ", "dim"),
+                (mask_api_key(resolved_key), ""),
+            )
+        else:
+            return Text.assemble(
+                (f"${{{env_var}}} ", ""),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
+    elif provider.api_key:
+        # Plain API key
+        return Text(mask_api_key(provider.api_key))
+    else:
+        return Text("N/A")
 
-    # Add providers
-    for provider in config.provider_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        name = Text(provider.provider_name, style=ThemeKey.CONFIG_ITEM_NAME)
-        protocol = Text(str(provider.protocol.value), style="")
-        base_url = Text(provider.base_url or "N/A", style="")
-        api_key = Text(mask_api_key(provider.api_key), style="")
-
-        providers_table.add_row(status, name, protocol, base_url, api_key)
-
-    # Display models section
-    models_table = Table.grid(padding=(0, 1), expand=True)
-    models_table.add_column(width=2, no_wrap=True)  # Status
-    models_table.add_column(overflow="fold", ratio=1)  # Name
-    models_table.add_column(overflow="fold", ratio=2)  # Model
-    models_table.add_column(overflow="fold", ratio=2)  # Provider
-    models_table.add_column(overflow="fold", ratio=3)  # Params
-
-    # Add header
-    models_table.add_row(
-        Text("", style="bold"),
-        Text("Name", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Model", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Provider", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-        Text("Params", style=f"bold {ThemeKey.CONFIG_TABLE_HEADER}"),
-    )
 
-    # Add models
-    for model in config.model_list:
-        status = Text("✔", style=f"bold {ThemeKey.CONFIG_STATUS_OK}")
-        if model.model_name == config.main_model:
-            status = Text("★", style=f"bold {ThemeKey.CONFIG_STATUS_PRIMARY}")  # Mark main model
-
-        name = Text(
-            model.model_name,
-            style=ThemeKey.CONFIG_STATUS_PRIMARY
-            if model.model_name == config.main_model
-            else ThemeKey.CONFIG_ITEM_NAME,
-        )
-        model_name = Text(model.model_params.model or "N/A", style="")
-        provider = Text(model.provider, style="")
-        params: list[Text] = []
-        if model.model_params.thinking:
-            if model.model_params.thinking.reasoning_effort is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_effort,
-                    )
-                )
-            if model.model_params.thinking.reasoning_summary is not None:
-                params.append(
-                    Text.assemble(
-                        ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        model.model_params.thinking.reasoning_summary,
-                    )
+def _get_model_params_display(model: ModelConfig) -> list[Text]:
+    """Get display elements for model parameters."""
+    params: list[Text] = []
+    if model.model_params.thinking:
+        if model.model_params.thinking.reasoning_effort is not None:
+            params.append(
+                Text.assemble(
+                    ("reason-effort", ThemeKey.CONFIG_PARAM_LABEL),
+                    ": ",
+                    model.model_params.thinking.reasoning_effort,
                 )
-            if model.model_params.thinking.budget_tokens is not None:
-                params.append(
-                    Text.assemble(
-                        ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
-                        ": ",
-                        str(model.model_params.thinking.budget_tokens),
-                    )
+            )
+        if model.model_params.thinking.reasoning_summary is not None:
+            params.append(
+                Text.assemble(
+                    ("reason-summary", ThemeKey.CONFIG_PARAM_LABEL),
+                    ": ",
+                    model.model_params.thinking.reasoning_summary,
                 )
-        if model.model_params.provider_routing:
+            )
+        if model.model_params.thinking.budget_tokens is not None:
             params.append(
                 Text.assemble(
-                    ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
+                    ("thinking-budget-tokens", ThemeKey.CONFIG_PARAM_LABEL),
                     ": ",
-                    model.model_params.provider_routing.model_dump_json(exclude_none=True),
+                    str(model.model_params.thinking.budget_tokens),
                 )
             )
-        if len(params) == 0:
-            params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
-        models_table.add_row(status, name, model_name, provider, Group(*params))
-
-    # Create panels and display
-    providers_panel = Panel(
-        providers_table,
-        title=Text("Providers Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
+    if model.model_params.provider_routing:
+        params.append(
+            Text.assemble(
+                ("provider-routing", ThemeKey.CONFIG_PARAM_LABEL),
+                ": ",
+                model.model_params.provider_routing.model_dump_json(exclude_none=True),
+            )
+        )
+    if len(params) == 0:
+        params.append(Text("N/A", style=ThemeKey.CONFIG_PARAM_LABEL))
+    return params
 
-    models_panel = Panel(
-        models_table,
-        title=Text("Models Configuration", style="white bold"),
-        border_style=ThemeKey.CONFIG_PANEL_BORDER,
-        padding=(0, 1),
-        title_align="left",
-    )
 
-    console.print(providers_panel)
-    console.print()
-    console.print(models_panel)
+def display_models_and_providers(config: Config):
+    """Display models and providers configuration using rich formatting"""
+    themes = get_theme(config.theme)
+    console = Console(theme=themes.app_theme)
+
+    # Display each provider as a separate panel
+    for provider in config.provider_list:
+        # Provider info section
+        provider_info = Table.grid(padding=(0, 1))
+        provider_info.add_column(width=12)
+        provider_info.add_column()
+
+        provider_info.add_row(
+            Text("Protocol:", style=ThemeKey.CONFIG_PARAM_LABEL),
+            Text(provider.protocol.value),
+        )
+        if provider.base_url:
+            provider_info.add_row(
+                Text("Base URL:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                Text(provider.base_url or "N/A"),
+            )
+        if provider.api_key:
+            provider_info.add_row(
+                Text("API Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                format_api_key_display(provider),
+            )
+
+        # Check if provider has valid API key
+        provider_available = not provider.is_api_key_missing()
+
+        # Models table for this provider
+        models_table = Table.grid(padding=(0, 1), expand=True)
+        models_table.add_column(width=2, no_wrap=True)  # Status
+        models_table.add_column(overflow="fold", ratio=1)  # Name
+        models_table.add_column(overflow="fold", ratio=2)  # Model
+        models_table.add_column(overflow="fold", ratio=3)  # Params
+
+        # Add header
+        models_table.add_row(
+            Text("", style="bold"),
+            Text("Name", style=ThemeKey.CONFIG_TABLE_HEADER),
+            Text("Model", style=ThemeKey.CONFIG_TABLE_HEADER),
+            Text("Params", style=ThemeKey.CONFIG_TABLE_HEADER),
+        )
+
+        # Add models for this provider
+        for model in provider.model_list:
+            if not provider_available:
+                # Provider API key not set - show as unavailable
+                status = Text("-", style="dim")
+                name = Text(model.model_name, style="dim")
+                model_id = Text(model.model_params.model or "N/A", style="dim")
+                params = [Text("(unavailable)", style="dim")]
+            elif model.model_name == config.main_model:
+                status = Text("★", style=ThemeKey.CONFIG_STATUS_PRIMARY)
+                name = Text(model.model_name, style=ThemeKey.CONFIG_STATUS_PRIMARY)
+                model_id = Text(model.model_params.model or "N/A", style="")
+                params = _get_model_params_display(model)
+            else:
+                status = Text("✔", style=ThemeKey.CONFIG_STATUS_OK)
+                name = Text(model.model_name, style=ThemeKey.CONFIG_ITEM_NAME)
+                model_id = Text(model.model_params.model or "N/A", style="")
+                params = _get_model_params_display(model)
+
+            models_table.add_row(status, name, model_id, Group(*params))
+
+        # Create panel content with provider info and models
+        panel_elements = [
+            provider_info,
+            Text(""),  # Spacer
+            Text("Models:", style=ThemeKey.CONFIG_TABLE_HEADER),
+            models_table,
+        ]
+
+        # Add Codex status if this is a codex provider
+        if provider.protocol == LLMClientProtocol.CODEX:
+            panel_elements.append(Text(""))  # Spacer
+            panel_elements.extend(_get_codex_status_elements())
+
+        panel_content = Group(*panel_elements)
+
+        panel = Panel(
+            panel_content,
+            title=Text(f"Provider: {provider.provider_name}", style="white bold"),
+            border_style=ThemeKey.CONFIG_PANEL_BORDER,
+            padding=(0, 1),
+            title_align="left",
+        )
+
+        console.print(panel)
+        console.print()
 
     # Display main model info
     console.print()
-    console.print(
-        Text.assemble(
-            ("Default Model: ", "bold"),
-            (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
+    if config.main_model:
+        console.print(
+            Text.assemble(
+                ("Default Model: ", "bold"),
+                (config.main_model, ThemeKey.CONFIG_STATUS_PRIMARY),
+            )
+        )
+    else:
+        console.print(
+            Text.assemble(
+                ("Default Model: ", "bold"),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
         )
-    )
 
     for profile in iter_sub_agent_profiles():
         sub_model_name = config.sub_agent_models.get(profile.name)
@@ -207,9 +254,3 @@ def display_models_and_providers(config: Config):
                 (sub_model_name, ThemeKey.CONFIG_STATUS_PRIMARY),
             )
         )
-
-    # Display Codex login status if any codex provider is configured
-    has_codex_provider = any(p.protocol.value == "codex" for p in config.provider_list)
-    if has_codex_provider:
-        console.print()
-        _display_codex_status(console)

klaude_code/cli/main.py

@@ -143,13 +143,28 @@ def exec_command(
         raise typer.Exit(1)
 
     from klaude_code.cli.runtime import AppInitConfig, run_exec
+    from klaude_code.config import load_config
     from klaude_code.config.select_model import select_model_from_config
 
     chosen_model = model
     if model or select_model:
         chosen_model = select_model_from_config(preferred=model)
         if chosen_model is None:
-            return
+            raise typer.Exit(1)
+    else:
+        # Check if main_model is configured; if not, trigger interactive selection
+        config = load_config()
+        if config.main_model is None:
+            chosen_model = select_model_from_config()
+            if chosen_model is None:
+                raise typer.Exit(1)
+            # Save the selection as default
+            config.main_model = chosen_model
+            from klaude_code.config.config import config_path
+            from klaude_code.trace import log
+
+            asyncio.run(config.save())
+            log(f"Saved main_model={chosen_model} to {config_path}", style="cyan")
 
     debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
@@ -275,8 +290,8 @@ def main_callback(
             session_meta = Session.load_meta(session_id)
             cfg = load_config()
 
-            if cfg is not None and session_meta.model_config_name:
-                if any(m.model_name == session_meta.model_config_name for m in cfg.model_list):
+            if session_meta.model_config_name:
+                if any(m.model_name == session_meta.model_config_name for m in cfg.iter_model_entries()):
                     chosen_model = session_meta.model_config_name
                 else:
                     log(
@@ -286,17 +301,34 @@ def main_callback(
                         )
                     )
 
-            if cfg is not None and chosen_model is None and session_meta.model_name:
+            if chosen_model is None and session_meta.model_name:
                 raw_model = session_meta.model_name.strip()
                 if raw_model:
                     matches = [
                         m.model_name
-                        for m in cfg.model_list
+                        for m in cfg.iter_model_entries()
                         if (m.model_params.model or "").strip().lower() == raw_model.lower()
                     ]
                     if len(matches) == 1:
                         chosen_model = matches[0]
 
+        # If still no model, check main_model; if not configured, trigger interactive selection
+        if chosen_model is None:
+            from klaude_code.config import load_config
+
+            cfg = load_config()
+            if cfg.main_model is None:
+                chosen_model = select_model_from_config()
+                if chosen_model is None:
+                    raise typer.Exit(1)
+                # Save the selection as default
+                cfg.main_model = chosen_model
+                from klaude_code.config.config import config_path
+                from klaude_code.trace import log
+
+                asyncio.run(cfg.save())
+                log(f"Saved main_model={chosen_model} to {config_path}", style="dim")
+
         debug_enabled, debug_filters, log_path = prepare_debug_logging(debug, debug_filter)
 
         init_config = AppInitConfig(

klaude_code/cli/runtime.py

@@ -62,8 +62,6 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     set_debug_logging(init_config.debug, filters=init_config.debug_filters)
 
     config = load_config()
-    if config is None:
-        raise typer.Exit(1)
 
     # Initialize LLM clients
     try:
@@ -160,7 +158,7 @@ async def initialize_session(
 def _backfill_session_model_config(
     agent: Agent | None,
     model_override: str | None,
-    default_model: str,
+    default_model: str | None,
     is_new_session: bool,
 ) -> None:
     """Backfill model_config_name and model_thinking on newly created sessions."""
@@ -169,7 +167,7 @@ def _backfill_session_model_config(
 
     if model_override is not None:
         agent.session.model_config_name = model_override
-    elif is_new_session:
+    elif is_new_session and default_model is not None:
         agent.session.model_config_name = default_model
     else:
         return
@@ -305,8 +303,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 printer.print(Text(f" {MSG} ", style="bold yellow reverse"))
             else:
                 print(MSG, file=sys.stderr)
-        except Exception:
-            # Fallback if themed print is unavailable
+        except (AttributeError, TypeError, RuntimeError):
+            # Fallback if themed print is unavailable (e.g., display not ready or Rich internal error)
             print(MSG, file=sys.stderr)
 
     def _hide_progress() -> None:

klaude_code/cli/self_update.py

@@ -174,7 +174,8 @@ def _print_version() -> None:
         ver = pkg_version(PACKAGE_NAME)
     except PackageNotFoundError:
         ver = "unknown"
-    except Exception:
+    except (ValueError, TypeError):
+        # Catch invalid package name format or type errors
         ver = "unknown"
     print(f"{PACKAGE_NAME} {ver}")
 

klaude_code/cli/session_cmd.py

@@ -13,7 +13,7 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
     def _fmt(ts: float) -> str:
         try:
             return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
-        except Exception:
+        except (OSError, OverflowError, ValueError):
             return str(ts)
 
     log(f"Sessions to delete ({len(sessions)}):")

klaude_code/config/__init__.py

@@ -1,7 +1,9 @@
-from .config import Config, config_path, load_config
+from .config import Config, UserConfig, config_path, load_config, print_no_available_models_hint
 
 __all__ = [
     "Config",
+    "UserConfig",
     "config_path",
     "load_config",
+    "print_no_available_models_hint",
 ]

klaude_code/config/assets/__init__.py

@@ -0,0 +1 @@
+# Asset files for config module