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

klaude_code/cli/main.py

@@ -7,19 +7,38 @@ from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.cost_cmd import register_cost_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, prepare_debug_logging
-from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
-from klaude_code.cli.session_cmd import register_session_commands
+from klaude_code.cli.self_update import register_self_upgrade_commands, version_option_callback
 from klaude_code.session import Session
 from klaude_code.tui.command.resume_cmd import select_session_sync
 from klaude_code.ui.terminal.title import update_terminal_title
 
-ENV_HELP = """\
-Environment Variables:
 
-  KLAUDE_READ_GLOBAL_LINE_CAP  Max lines to read (default: 2000)
-
-  KLAUDE_READ_MAX_CHARS        Max total chars to read (default: 50000)
-"""
+def _build_env_help() -> str:
+    from klaude_code.config.builtin_config import SUPPORTED_API_KEYS
+
+    lines = [
+        "Environment Variables:",
+        "",
+        "Provider API keys (built-in config):",
+    ]
+    # Calculate max env_var length for alignment
+    max_len = max(len(k.env_var) for k in SUPPORTED_API_KEYS)
+    for k in SUPPORTED_API_KEYS:
+        lines.append(f"  {k.env_var:<{max_len}}  {k.description}")
+    lines.extend(
+        [
+            "",
+            "Tool limits (Read):",
+            "  KLAUDE_READ_GLOBAL_LINE_CAP    Max lines to read (default: 2000)",
+            "  KLAUDE_READ_MAX_CHARS          Max total chars to read (default: 50000)",
+            "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 4MB)",
+            "  KLAUDE_IMAGE_OUTPUT_MAX_BYTES  Max decoded image bytes (default: 64MB)",
+        ]
+    )
+    return "\n\n".join(lines)
+
+
+ENV_HELP = _build_env_help()
 
 app = typer.Typer(
     add_completion=False,
@@ -27,55 +46,51 @@ app = typer.Typer(
     no_args_is_help=False,
     rich_markup_mode="rich",
     epilog=ENV_HELP,
+    context_settings={"help_option_names": ["-h", "--help"]},
 )
 
 # Register subcommands from modules
-register_session_commands(app)
 register_auth_commands(app)
 register_config_commands(app)
 register_cost_commands(app)
+register_self_upgrade_commands(app)
+
 
-register_self_update_commands(app)
+@app.command("help", hidden=True)
+def help_command(ctx: typer.Context) -> None:
+    """Show help message."""
+    print(ctx.parent.get_help() if ctx.parent else ctx.get_help())
 
 
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        "-v",
-        help="Show version and exit",
-        callback=version_option_callback,
-        is_eager=True,
-    ),
     model: str | None = typer.Option(
         None,
         "--model",
         "-m",
-        help="Override model config name (uses main model by default)",
+        help="Select model by name",
         rich_help_panel="LLM",
     ),
-    continue_: bool = typer.Option(False, "--continue", "-c", help="Continue from latest session"),
-    resume: bool = typer.Option(False, "--resume", "-r", help="Select a session to resume for this project"),
+    continue_: bool = typer.Option(False, "--continue", "-c", help="Resume latest session"),
+    resume: bool = typer.Option(False, "--resume", "-r", help="Pick a session to resume"),
     resume_by_id: str | None = typer.Option(
         None,
         "--resume-by-id",
-        help="Resume a session by its ID (must exist)",
+        help="Resume session by ID",
     ),
     select_model: bool = typer.Option(
         False,
         "--select-model",
         "-s",
-        help="Interactively choose a model at startup",
+        help="Choose model interactively",
         rich_help_panel="LLM",
     ),
     debug: bool = typer.Option(
         False,
         "--debug",
         "-d",
-        help="Enable debug mode",
+        help="Enable debug logging",
         rich_help_panel="Debug",
     ),
     debug_filter: str | None = typer.Option(
@@ -87,14 +102,23 @@ def main_callback(
     vanilla: bool = typer.Option(
         False,
         "--vanilla",
-        help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read, Write & Edit) and omits system prompts and reminders.",
+        help="Minimal mode: basic tools only, no system prompts",
     ),
     banana: bool = typer.Option(
         False,
         "--banana",
-        help="Image generation mode with Nano Banana",
+        help="Image generation mode",
         rich_help_panel="LLM",
     ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        "-v",
+        help="Show version and exit",
+        callback=version_option_callback,
+        is_eager=True,
+    ),
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:

klaude_code/cli/self_update.py

@@ -35,14 +35,14 @@ def version_command() -> None:
     _print_version()
 
 
-def update_command(
+def upgrade_command(
     check: bool = typer.Option(
         False,
         "--check",
-        help="Check for updates and exit without upgrading",
+        help="Check only, don't upgrade",
     ),
 ) -> None:
-    """Upgrade klaude-code when installed via `uv tool`."""
+    """Upgrade to latest version"""
 
     info = check_for_updates_blocking()
 
@@ -79,9 +79,9 @@ def update_command(
     log("Update complete. Please re-run `klaude` to use the new version.")
 
 
-def register_self_update_commands(app: typer.Typer) -> None:
+def register_self_upgrade_commands(app: typer.Typer) -> None:
     """Register self-update and version subcommands to the given Typer app."""
 
-    app.command("update")(update_command)
-    app.command("upgrade", help="Alias for `klaude update`.")(update_command)
-    app.command("version", help="Alias for `klaude --version`.")(version_command)
+    app.command("upgrade")(upgrade_command)
+    app.command("update", hidden=True)(upgrade_command)
+    app.command("version", hidden=True)(version_command)

klaude_code/config/assets/builtin_config.yaml

@@ -1,4 +1,3 @@
----
 # Built-in provider and model configurations
 # Users can start using klaude by simply setting environment variables
 # (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without manual configuration.
@@ -25,32 +24,58 @@ provider_list:
   protocol: responses
   api_key: ${OPENAI_API_KEY}
   model_list:
-  - model_name: gpt-5.2
+  - model_name: gpt-5.2-high
     model_id: gpt-5.2
     max_tokens: 128000
     context_limit: 400000
     verbosity: high
     thinking:
       reasoning_effort: high
+      reasoning_summary: detailed
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-medium
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: high
+    thinking:
+      reasoning_effort: medium
+      reasoning_summary: concise
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-low
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: low
+    thinking:
+      reasoning_effort: low
+      reasoning_summary: concise
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-fast
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: low
+    thinking:
+      reasoning_effort: none
     cost: {input: 1.75, output: 14, cache_read: 0.17}
-- provider_name: openrouter
-  protocol: openrouter
-  api_key: ${OPENROUTER_API_KEY}
-  model_list:
   - model_name: gpt-5.1-codex-max
-    model_id: openai/gpt-5.1-codex-max
+    model_id: gpt-5.1-codex-max
     max_tokens: 128000
     context_limit: 400000
     thinking:
       reasoning_effort: medium
+      reasoning_summary: detailed
     cost: {input: 1.25, output: 10, cache_read: 0.13}
-  - model_name: gpt-5.2
+- provider_name: openrouter
+  protocol: openrouter
+  api_key: ${OPENROUTER_API_KEY}
+  model_list:
+  - model_name: gpt-5.2-high
     model_id: openai/gpt-5.2
     max_tokens: 128000
     context_limit: 400000
     verbosity: high
     thinking:
       reasoning_effort: high
+      reasoning_summary: detailed
     cost: {input: 1.75, output: 14, cache_read: 0.17}
   - model_name: gpt-5.2-medium
     model_id: openai/gpt-5.2
@@ -59,22 +84,7 @@ provider_list:
     verbosity: high
     thinking:
       reasoning_effort: medium
-    cost: {input: 1.75, output: 14, cache_read: 0.17}
-  - model_name: gpt-5.2-low
-    model_id: openai/gpt-5.2
-    max_tokens: 128000
-    context_limit: 400000
-    verbosity: low
-    thinking:
-      reasoning_effort: low
-    cost: {input: 1.75, output: 14, cache_read: 0.17}
-  - model_name: gpt-5.2-fast
-    model_id: openai/gpt-5.2
-    max_tokens: 128000
-    context_limit: 400000
-    verbosity: low
-    thinking:
-      reasoning_effort: none
+      reasoning_summary: concise
     cost: {input: 1.75, output: 14, cache_read: 0.17}
   - model_name: kimi
     model_id: moonshotai/kimi-k2-thinking
@@ -165,10 +175,14 @@ provider_list:
   - model_name: gemini-pro
     model_id: gemini-3-pro-preview
     context_limit: 1048576
+    thinking:
+      reasoning_effort: high
     cost: {input: 2, output: 12, cache_read: 0.2}
   - model_name: gemini-flash
     model_id: gemini-3-flash-preview
     context_limit: 1048576
+    thinking:
+      reasoning_effort: medium
     cost: {input: 0.5, output: 3, cache_read: 0.05}
   - model_name: nano-banana-pro
     model_id: gemini-3-pro-image-preview
@@ -177,6 +191,13 @@ provider_list:
     - image
     - text
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
+  - model_name: nano-banana
+    model_id: gemini-2.5-flash-image
+    context_limit: 33000
+    modalities:
+    - image
+    - text
+    cost: {input: 0.3, output: 2.5, cache_read: 0.03, image: 30}
 - provider_name: bedrock
   protocol: bedrock
   aws_access_key: ${AWS_ACCESS_KEY_ID}

klaude_code/config/builtin_config.py

@@ -5,6 +5,7 @@ environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without
 manually configuring providers.
 """
 
+from dataclasses import dataclass
 from functools import lru_cache
 from importlib import resources
 from typing import TYPE_CHECKING, Any
@@ -14,15 +15,28 @@ import yaml
 if TYPE_CHECKING:
     from klaude_code.config.config import ProviderConfig
 
-# All supported API key environment variables
-SUPPORTED_API_KEY_ENVS = [
-    "ANTHROPIC_API_KEY",
-    "GOOGLE_API_KEY",
-    "OPENAI_API_KEY",
-    "OPENROUTER_API_KEY",
-    "DEEPSEEK_API_KEY",
-    "MOONSHOT_API_KEY",
-]
+
+@dataclass(frozen=True)
+class ApiKeyInfo:
+    """Information about a supported API key."""
+
+    env_var: str
+    name: str
+    description: str
+
+
+# All supported API keys with their metadata
+SUPPORTED_API_KEYS: tuple[ApiKeyInfo, ...] = (
+    ApiKeyInfo("ANTHROPIC_API_KEY", "Anthropic", "Anthropic API key"),
+    ApiKeyInfo("OPENAI_API_KEY", "OpenAI", "OpenAI API key"),
+    ApiKeyInfo("OPENROUTER_API_KEY", "OpenRouter", "OpenRouter API key"),
+    ApiKeyInfo("GOOGLE_API_KEY", "Google Gemini", "Google API key (Gemini)"),
+    ApiKeyInfo("DEEPSEEK_API_KEY", "DeepSeek", "DeepSeek API key"),
+    ApiKeyInfo("MOONSHOT_API_KEY", "Moonshot Kimi", "Moonshot API key (Kimi)"),
+)
+
+# For backwards compatibility
+SUPPORTED_API_KEY_ENVS = [k.env_var for k in SUPPORTED_API_KEYS]
 
 
 @lru_cache(maxsize=1)

klaude_code/config/config.py

@@ -8,8 +8,9 @@ from typing import Any, cast
 import yaml
 from pydantic import BaseModel, Field, ValidationError, model_validator
 
+from klaude_code.auth.env import get_auth_env
 from klaude_code.config.builtin_config import (
-    SUPPORTED_API_KEY_ENVS,
+    SUPPORTED_API_KEYS,
     get_builtin_provider_configs,
     get_builtin_sub_agent_models,
 )
@@ -26,7 +27,8 @@ def parse_env_var_syntax(value: str | None) -> tuple[str | None, str | None]:
 
     Returns:
         A tuple of (env_var_name, resolved_value).
-        - If value uses ${ENV_VAR} syntax: (env_var_name, os.environ.get(env_var_name))
+        - If value uses ${ENV_VAR} syntax: (env_var_name, resolved_value)
+          Priority: os.environ > klaude-auth.json env section
         - If value is a plain string: (None, value)
         - If value is None: (None, None)
     """
@@ -36,7 +38,9 @@ def parse_env_var_syntax(value: str | None) -> tuple[str | None, str | None]:
     match = _ENV_VAR_PATTERN.match(value)
     if match:
         env_var_name = match.group(1)
-        return env_var_name, os.environ.get(env_var_name)
+        # Priority: real env var > auth.json env section
+        resolved = os.environ.get(env_var_name) or get_auth_env(env_var_name)
+        return env_var_name, resolved
 
     return None, value
 
@@ -613,17 +617,23 @@ def load_config() -> Config:
 
 def print_no_available_models_hint() -> None:
     """Print helpful message when no models are available due to missing API keys."""
-    log("No available models. Please set one of the following environment variables:", style="yellow")
+    log("No available models. Configure an API key using one of these methods:", style="yellow")
     log("")
-    for env_var in SUPPORTED_API_KEY_ENVS:
-        current_value = os.environ.get(env_var)
+    log("Option 1: Use klaude auth login", style="bold")
+    # Use first word of name for brevity
+    names = [k.name.split()[0].lower() for k in SUPPORTED_API_KEYS]
+    log(f"  klaude auth login <provider>  (providers: {', '.join(names)})", style="dim")
+    log("")
+    log("Option 2: Set environment variables", style="bold")
+    max_len = max(len(k.env_var) for k in SUPPORTED_API_KEYS)
+    for key_info in SUPPORTED_API_KEYS:
+        current_value = os.environ.get(key_info.env_var) or get_auth_env(key_info.env_var)
         if current_value:
-            log(f"  {env_var} = (set)", style="green")
+            log(f"  {key_info.env_var:<{max_len}}  (set)", style="green")
         else:
-            log(f"  export {env_var}=<your-api-key>", style="dim")
+            log(f"  {key_info.env_var:<{max_len}}  {key_info.description}", style="dim")
     log("")
     log(f"Or add custom providers in: {config_path}", style="dim")
-    log(f"See example config: {example_config_path}", style="dim")
 
 
 # Expose cache control for tests and callers that need to invalidate the cache.

klaude_code/config/model_matcher.py

@@ -102,6 +102,7 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
             )
 
         # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
+        # Only match selector/model_name exactly; model_id is checked via substring match below
         preferred_norm = _normalize_model_key(preferred)
         normalized_matches: list[ModelEntry] = []
         if preferred_norm:
@@ -110,7 +111,6 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
                 for m in models
                 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(

klaude_code/const.py

@@ -27,6 +27,7 @@ def _get_int_env(name: str, default: int) -> int:
 # =============================================================================
 
 MAX_FAILED_TURN_RETRIES = 10  # Maximum retry attempts for failed turns
+RETRY_PRESERVE_PARTIAL_MESSAGE = True  # Preserve partial message on stream error for retry prefill
 LLM_HTTP_TIMEOUT_TOTAL = 300.0  # HTTP timeout for LLM API requests (seconds)
 LLM_HTTP_TIMEOUT_CONNECT = 15.0  # HTTP connect timeout (seconds)
 LLM_HTTP_TIMEOUT_READ = 285.0  # HTTP read timeout (seconds)
@@ -157,7 +158,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 = "Connecting …"
+STATUS_WAITING_TEXT = "Loading …"
 STATUS_THINKING_TEXT = "Thinking …"
 STATUS_COMPOSING_TEXT = "Composing"
 

klaude_code/core/tool/file/edit_tool.py

@@ -98,7 +98,7 @@ class EditTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: edit</tool_use_error>",
             )
 
         if args.old_string == "":

klaude_code/core/tool/file/read_tool.py

@@ -210,7 +210,7 @@ class ReadTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: read</tool_use_error>",
             )
         if not file_exists(file_path):
             return message.ToolResultMessage(
@@ -308,7 +308,7 @@ class ReadTool(ToolABC):
         except IsADirectoryError:
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: read</tool_use_error>",
             )
 
         if offset > max(read_result.total_lines, 0):

klaude_code/core/tool/file/write_tool.py

@@ -57,7 +57,7 @@ class WriteTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: write</tool_use_error>",
             )
 
         file_tracker = context.file_tracker

klaude_code/core/turn.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncGenerator
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from klaude_code.const import SUPPORTED_IMAGE_SIZES
+from klaude_code.const import RETRY_PRESERVE_PARTIAL_MESSAGE, SUPPORTED_IMAGE_SIZES
 from klaude_code.core.tool import ToolABC
 from klaude_code.core.tool.context import SubAgentResumeClaims, ToolContext
 
@@ -24,6 +24,14 @@ from klaude_code.llm.client import LLMStreamABC
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events, llm_param, message, model, tools
 
+# Protocols that support prefill (continuing from partial assistant message)
+_PREFILL_SUPPORTED_PROTOCOLS = frozenset(
+    {
+        "anthropic",
+        "claude_oauth",
+    }
+)
+
 
 class TurnError(Exception):
     """Raised when a turn fails and should be retried."""
@@ -176,7 +184,19 @@ class TurnExecutor:
             yield event
 
         if self._turn_result.stream_error is not None:
+            # Save accumulated content for potential prefill on retry (only for supported protocols)
             session_ctx.append_history([self._turn_result.stream_error])
+            protocol = ctx.llm_client.get_llm_config().protocol
+            supports_prefill = protocol.value in _PREFILL_SUPPORTED_PROTOCOLS
+            if (
+                RETRY_PRESERVE_PARTIAL_MESSAGE
+                and supports_prefill
+                and self._turn_result.assistant_message is not None
+                and self._turn_result.assistant_message.parts
+            ):
+                session_ctx.append_history([self._turn_result.assistant_message])
+                # Add continuation prompt to avoid Anthropic thinking block requirement
+                session_ctx.append_history([message.UserMessage(parts=[message.TextPart(text="continue")])])
             yield events.TurnEndEvent(session_id=session_ctx.session_id)
             raise TurnError(self._turn_result.stream_error.error)
 
@@ -231,9 +251,6 @@ class TurnExecutor:
             image_size = generation.get("image_size")
             if image_size in SUPPORTED_IMAGE_SIZES:
                 image_config.image_size = image_size
-            extra = generation.get("extra")
-            if isinstance(extra, dict) and extra:
-                image_config.extra = extra
             if image_config.model_dump(exclude_none=True):
                 call_param.image_config = image_config