klaude-code 1.2.11__py3-none-any.whl → 1.2.12__py3-none-any.whl

klaude_code/command/__init__.py

@@ -5,7 +5,7 @@ from .registry import (
     has_interactive_command,
     is_slash_command_name,
     load_prompt_commands,
-    register_command,
+    register,
 )
 
 # Lazy load commands to avoid heavy imports at module load time
@@ -17,38 +17,41 @@ def ensure_commands_loaded() -> None:
 
     This function is called internally by registry functions like get_commands(),
     dispatch_command(), etc. It can also be called explicitly if early loading is desired.
+
+    Commands are registered in display order - the order here determines
+    the order shown in slash command completion.
     """
     global _commands_loaded
     if _commands_loaded:
         return
     _commands_loaded = True
 
-    # Import command modules to trigger @register_command decorators
-    from . import clear_cmd as _clear_cmd  # noqa: F401
-    from . import diff_cmd as _diff_cmd  # noqa: F401
-    from . import export_cmd as _export_cmd  # noqa: F401
-    from . import help_cmd as _help_cmd  # noqa: F401
-    from . import model_cmd as _model_cmd  # noqa: F401
-    from . import refresh_cmd as _refresh_cmd  # noqa: F401
-    from . import release_notes_cmd as _release_notes_cmd  # noqa: F401
-    from . import status_cmd as _status_cmd  # noqa: F401
-    from . import terminal_setup_cmd as _terminal_setup_cmd  # noqa: F401
-
-    # Suppress unused variable warnings
-    _ = (
-        _clear_cmd,
-        _diff_cmd,
-        _export_cmd,
-        _help_cmd,
-        _model_cmd,
-        _refresh_cmd,
-        _release_notes_cmd,
-        _status_cmd,
-        _terminal_setup_cmd,
-    )
+    # Import and register commands in display order
+    from .clear_cmd import ClearCommand
+    from .model_cmd import ModelCommand
+    from .status_cmd import StatusCommand
+    from .diff_cmd import DiffCommand
+    from .export_cmd import ExportCommand
+    from .thinking_cmd import ThinkingCommand
+    from .help_cmd import HelpCommand
+    from .refresh_cmd import RefreshTerminalCommand
+    from .terminal_setup_cmd import TerminalSetupCommand
+    from .release_notes_cmd import ReleaseNotesCommand
 
-    # Load prompt-based commands
+    # Register in desired display order
+    register(ExportCommand())
+    register(RefreshTerminalCommand())
+    register(ThinkingCommand())
+    register(ModelCommand())
     load_prompt_commands()
+    register(ClearCommand())
+    register(StatusCommand())
+    register(DiffCommand())
+    register(HelpCommand())
+    register(ReleaseNotesCommand())
+    register(TerminalSetupCommand())
+
+    # Load prompt-based commands (appended after built-in commands)
 
 
 # Lazy accessors for command classes
@@ -63,6 +66,7 @@ def __getattr__(name: str) -> object:
         "ReleaseNotesCommand": "release_notes_cmd",
         "StatusCommand": "status_cmd",
         "TerminalSetupCommand": "terminal_setup_cmd",
+        "ThinkingCommand": "thinking_cmd",
     }
     if name in _commands_map:
         import importlib
@@ -77,7 +81,6 @@ __all__ = [
     # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
     # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
     # "StatusCommand", "TerminalSetupCommand",
-    "register_command",
     "CommandABC",
     "CommandResult",
     "InputAction",

klaude_code/command/clear_cmd.py

@@ -1,14 +1,12 @@
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class ClearCommand(CommandABC):
     """Clear current session and start a new conversation"""
 

klaude_code/command/diff_cmd.py

@@ -3,14 +3,12 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class DiffCommand(CommandABC):
     """Show git diff for the current repository."""
 

klaude_code/command/export_cmd.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html, get_default_export_path
 
@@ -13,7 +12,6 @@ if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class ExportCommand(CommandABC):
     """Export the current session into a standalone HTML transcript."""
 

klaude_code/command/help_cmd.py

@@ -1,14 +1,12 @@
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class HelpCommand(CommandABC):
     """Display help information for all available slash commands."""
 

klaude_code/command/model_cmd.py

@@ -2,7 +2,6 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.command.registry import register_command
 from klaude_code.config import select_model_from_config
 from klaude_code.protocol import commands, events, model
 
@@ -10,7 +9,6 @@ if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
 

klaude_code/command/refresh_cmd.py

@@ -1,14 +1,12 @@
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class RefreshTerminalCommand(CommandABC):
     """Refresh terminal display"""
 

klaude_code/command/registry.py

@@ -1,5 +1,5 @@
 from importlib.resources import files
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
@@ -13,14 +13,10 @@ if TYPE_CHECKING:
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
 
-T = TypeVar("T", bound="CommandABC")
 
-
-def register_command(cls: type[T]) -> type[T]:
-    """Decorator to register a command class in the global registry."""
-    instance = cls()
-    _COMMANDS[instance.name] = instance
-    return cls
+def register(cmd: "CommandABC") -> None:
+    """Register a command instance. Order of registration determines display order."""
+    _COMMANDS[cmd.name] = cmd
 
 
 def load_prompt_commands():

klaude_code/command/release_notes_cmd.py

@@ -2,7 +2,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:
@@ -62,7 +61,6 @@ def _extract_releases(changelog: str, count: int = 1) -> str:
     return "\n".join("\n".join(release) for release in releases).strip()
 
 
-@register_command
 class ReleaseNotesCommand(CommandABC):
     """Display the latest release notes from CHANGELOG.md."""
 

klaude_code/command/status_cmd.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
@@ -60,8 +59,8 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
             total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
 
         # Track peak context window size (max across all tasks)
-        if usage.context_token is not None:
-            total.context_token = usage.context_token
+        if usage.context_size is not None:
+            total.context_size = usage.context_size
 
         # Keep the latest context_limit for computed context_usage_percent
         if usage.context_limit is not None:
@@ -127,7 +126,6 @@ def format_status_content(aggregated: AggregatedUsage) -> str:
     return "\n".join(lines)
 
 
-@register_command
 class StatusCommand(CommandABC):
     """Display session usage statistics."""
 

klaude_code/command/terminal_setup_cmd.py

@@ -4,14 +4,12 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-@register_command
 class TerminalSetupCommand(CommandABC):
     """Setup shift+enter newline functionality in terminal"""
 

klaude_code/command/thinking_cmd.py

@@ -0,0 +1,227 @@
+import asyncio
+from typing import TYPE_CHECKING
+
+import questionary
+
+from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.protocol import commands, events, llm_param, model
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
+
+# Thinking level options for different protocols
+RESPONSES_LEVELS = ["minimal", "low", "medium", "high"]
+RESPONSES_GPT51_LEVELS = ["none", "minimal", "low", "medium", "high"]
+RESPONSES_CODEX_MAX_LEVELS = ["medium", "high", "xhigh"]
+
+ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
+    ("off", 0),
+    ("low (2048 tokens)", 2048),
+    ("medium (8192 tokens)", 8192),
+    ("high (31999 tokens)", 31999),
+]
+
+
+def _is_openrouter_model_with_reasoning_effort(model_name: str | None) -> bool:
+    """Check if the model is GPT series, Grok or Gemini 3."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return model_lower.startswith(("openai/gpt-", "x-ai/grok-", "google/gemini-3"))
+
+
+def _is_gpt51_model(model_name: str | None) -> bool:
+    """Check if the model is GPT-5.1."""
+    if not model_name:
+        return False
+    return model_name.lower() in ["gpt5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
+
+
+def _is_codex_max_model(model_name: str | None) -> bool:
+    """Check if the model is GPT-5.1-codex-max."""
+    if not model_name:
+        return False
+    return "codex-max" in model_name.lower()
+
+
+def _get_levels_for_responses(model_name: str | None) -> list[str]:
+    """Get thinking levels for responses protocol."""
+    if _is_codex_max_model(model_name):
+        return RESPONSES_CODEX_MAX_LEVELS
+    if _is_gpt51_model(model_name):
+        return RESPONSES_GPT51_LEVELS
+    return RESPONSES_LEVELS
+
+
+def _format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
+    """Format the current thinking configuration for display."""
+    thinking = config.thinking
+    if not thinking:
+        return "not configured"
+
+    protocol = config.protocol
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        if thinking.reasoning_effort:
+            return f"reasoning_effort={thinking.reasoning_effort}"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        if thinking.type == "disabled":
+            return "off"
+        if thinking.type == "enabled":
+            return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if _is_openrouter_model_with_reasoning_effort(config.model):
+            if thinking.reasoning_effort:
+                return f"reasoning_effort={thinking.reasoning_effort}"
+        else:
+            if thinking.type == "disabled":
+                return "off"
+            if thinking.type == "enabled":
+                return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        if thinking.type == "disabled":
+            return "off"
+        if thinking.type == "enabled":
+            return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
+    return "unknown protocol"
+
+
+SELECT_STYLE = questionary.Style([
+    ("instruction", "ansibrightblack"),
+    ("pointer", "ansicyan"),
+    ("highlighted", "ansicyan"),
+    ("text", "ansibrightblack"),
+])
+
+
+def _select_responses_thinking_sync(model_name: str | None) -> llm_param.Thinking | None:
+    """Select thinking level for responses/codex protocol (sync version)."""
+    levels = _get_levels_for_responses(model_name)
+    choices: list[questionary.Choice] = [questionary.Choice(title=level, value=level) for level in levels]
+
+    try:
+        result = questionary.select(
+            message="Select reasoning effort:",
+            choices=choices,
+            pointer="→",
+            instruction="Use arrow keys to move, Enter to select",
+            use_jk_keys=False,
+            style=SELECT_STYLE,
+        ).ask()
+
+        if result is None:
+            return None
+        return llm_param.Thinking(reasoning_effort=result)
+    except KeyboardInterrupt:
+        return None
+
+
+def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
+    """Select thinking level for anthropic/openai_compatible protocol (sync version)."""
+    choices: list[questionary.Choice] = [
+        questionary.Choice(title=label, value=tokens) for label, tokens in ANTHROPIC_LEVELS
+    ]
+
+    try:
+        result = questionary.select(
+            message="Select thinking level:",
+            choices=choices,
+            pointer="→",
+            instruction="Use arrow keys to move, Enter to select",
+            use_jk_keys=False,
+            style=SELECT_STYLE,
+        ).ask()
+        if result is None:
+            return llm_param.Thinking(type="disabled", budget_tokens=0)
+        return llm_param.Thinking(type="enabled", budget_tokens=result or 0)
+    except KeyboardInterrupt:
+        return None
+
+
+class ThinkingCommand(CommandABC):
+    """Configure model thinking/reasoning level."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.THINKING
+
+    @property
+    def summary(self) -> str:
+        return "Configure model thinking/reasoning level"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+        if not agent.profile:
+            return self._no_change_result(agent, "No profile configured")
+
+        config = agent.profile.llm_client.get_llm_config()
+        protocol = config.protocol
+        model_name = config.model
+
+        current = _format_current_thinking(config)
+
+        # Select new thinking configuration based on protocol
+        new_thinking: llm_param.Thinking | None = None
+
+        if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+            new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+
+        elif protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+        elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
+            if _is_openrouter_model_with_reasoning_effort(model_name):
+                new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+            else:
+                new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+        elif protocol == llm_param.LLMClientProtocol.OPENAI:
+            # openai_compatible uses anthropic style
+            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+        else:
+            return self._no_change_result(agent, f"Unsupported protocol: {protocol}")
+
+        if new_thinking is None:
+            return self._no_change_result(agent, "(no change)")
+
+        # Apply the new thinking configuration
+        config.thinking = new_thinking
+        new_status = _format_current_thinking(config)
+
+        return CommandResult(
+            events=[
+                events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=f"Thinking changed: {current} -> {new_status}",
+                        command_output=model.CommandOutput(command_name=self.name),
+                    ),
+                )
+            ]
+        )
+
+    def _no_change_result(self, agent: "Agent", message: str) -> CommandResult:
+        return CommandResult(
+            events=[
+                events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=message,
+                        command_output=model.CommandOutput(command_name=self.name),
+                    ),
+                )
+            ]
+        )

klaude_code/config/select_model.py

@@ -1,6 +1,5 @@
 from klaude_code.config.config import load_config
 from klaude_code.trace import log
-from klaude_code.ui.rich.searchable_text import SearchableFormattedList
 
 
 def select_model_from_config(preferred: str | None = None) -> str | None:
@@ -16,9 +15,6 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
         raise ValueError("No models configured. Please update your config.yaml")
 
     names: list[str] = [m.model_name for m in models]
-    default_name: str | None = (
-        preferred if preferred in names else (config.main_model if config.main_model in names else None)
-    )
 
     try:
         import questionary
@@ -28,29 +24,23 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
         max_model_name_length = max(len(m.model_name) for m in models)
         for m in models:
             star = "★ " if m.model_name == config.main_model else "  "
-            fragments = [
-                ("class:t", f"{star}{m.model_name:<{max_model_name_length}}   → "),
-                ("class:b", m.model_params.model or "N/A"),
-                ("class:d", f" {m.provider}"),
-            ]
-            # Provide a formatted title for display and a plain text for search.
-            title = SearchableFormattedList(fragments)
+            title = f"{star}{m.model_name:<{max_model_name_length}}   →  {m.model_params.model or 'N/A'} @ {m.provider}"
             choices.append(questionary.Choice(title=title, value=m.model_name))
 
         try:
             result = questionary.select(
                 message="Select a model:",
                 choices=choices,
-                default=default_name,
                 pointer="→",
                 instruction="↑↓ to move • Enter to select",
                 use_jk_keys=False,
                 use_search_filter=True,
                 style=questionary.Style(
                     [
-                        ("t", ""),
-                        ("b", "bold"),
-                        ("d", "dim"),
+                        ("instruction", "ansibrightblack"),
+                        ("pointer", "ansicyan"),
+                        ("highlighted", "ansicyan"),
+                        ("text", "ansibrightblack"),
                         # search filter colors at the bottom
                         ("search_success", "noinherit fg:ansigreen"),
                         ("search_none", "noinherit fg:ansired"),

klaude_code/const/__init__.py

@@ -62,7 +62,7 @@ BASH_DEFAULT_TIMEOUT_MS = 120000
 
 # -- Tool Output --
 # Maximum length for tool output before truncation
-TOOL_OUTPUT_MAX_LENGTH = 50000
+TOOL_OUTPUT_MAX_LENGTH = 40000
 
 # Characters to show from the beginning of truncated output
 TOOL_OUTPUT_DISPLAY_HEAD = 10000

klaude_code/core/agent.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncGenerator, Callable, Iterable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Protocol
 
-from klaude_code.core.prompt import get_system_prompt as load_system_prompt
+from klaude_code.core.prompt import load_system_prompt
 from klaude_code.core.reminders import Reminder, load_agent_reminders
 from klaude_code.core.task import SessionContext, TaskExecutionContext, TaskExecutor
 from klaude_code.core.tool import build_todo_context, get_registry, load_agent_tools
@@ -122,7 +122,6 @@ class Agent:
         self.session: Session = session
         self.profile: AgentProfile = profile
         self._current_task: TaskExecutor | None = None
-        self._prev_context_token: int = 0  # Track context size from previous task for delta calculation
         if not self.session.model_name and model_name:
             self.session.model_name = model_name
 
@@ -170,12 +169,6 @@ class Agent:
 
         try:
             async for event in task.run(user_input):
-                # Compute context_delta for TaskMetadataEvent
-                if isinstance(event, events.TaskMetadataEvent):
-                    usage = event.metadata.main.usage
-                    if usage is not None and usage.context_token is not None:
-                        usage.context_delta = usage.context_token - self._prev_context_token
-                        self._prev_context_token = usage.context_token
                 yield event
         finally:
             self._current_task = None

klaude_code/core/prompt.py

@@ -84,7 +84,7 @@ def _build_env_info(model_name: str) -> str:
     return "\n".join(env_lines)
 
 
-def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
+def load_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
     """Get system prompt content for the given model and sub-agent type."""
     file_key = _get_file_key(model_name, sub_agent_type)
     base_prompt = _load_base_prompt(file_key)

klaude_code/core/task.py

@@ -45,11 +45,10 @@ class MetadataAccumulator:
             acc_usage.cached_tokens += usage.cached_tokens
             acc_usage.reasoning_tokens += usage.reasoning_tokens
             acc_usage.output_tokens += usage.output_tokens
-            acc_usage.last_turn_output_token = usage.output_tokens
             acc_usage.currency = usage.currency
 
-            if usage.context_token is not None:
-                acc_usage.context_token = usage.context_token
+            if usage.context_size is not None:
+                acc_usage.context_size = usage.context_size
             if usage.context_limit is not None:
                 acc_usage.context_limit = usage.context_limit
 

klaude_code/core/turn.py

@@ -158,7 +158,6 @@ class TurnExecutor:
                 input=session_ctx.get_conversation_history(),
                 system=ctx.system_prompt,
                 tools=ctx.tools,
-                store=False,
                 session_id=session_ctx.session_id,
             )
         ):