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

klaude_code/cli/main.py

@@ -3,7 +3,6 @@ import datetime
 import os
 import subprocess
 import sys
-import uuid
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
 
@@ -340,8 +339,8 @@ def main_callback(
                 return
 
         # Resolve session id before entering asyncio loop
+        # session_id=None means create a new session
         session_id: str | None = None
-        is_new_session = False
         if resume:
             session_id = resume_select_session()
             if session_id is None:
@@ -349,10 +348,7 @@ def main_callback(
         # If user didn't pick, allow fallback to --continue
         if session_id is None and continue_:
             session_id = Session.most_recent_session_id()
-        # If still no session_id, generate a new one for a new session
-        if session_id is None:
-            session_id = uuid.uuid4().hex
-            is_new_session = True
+        # If still no session_id, leave as None to create a new session
 
         debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
 
@@ -367,6 +363,5 @@ def main_callback(
             run_interactive(
                 init_config=init_config,
                 session_id=session_id,
-                is_new_session=is_new_session,
             )
         )

klaude_code/cli/runtime.py

@@ -1,6 +1,5 @@
 import asyncio
 import sys
-import uuid
 from dataclasses import dataclass
 from typing import Any, Protocol
 
@@ -15,7 +14,6 @@ from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
 from klaude_code.protocol import events, op
 from klaude_code.protocol.model import UserInputPayload
-from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.trace import DebugType, log, set_debug_logging
 from klaude_code.ui.modes.repl import build_repl_status_snapshot
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
@@ -97,11 +95,9 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
 
     # Initialize LLM clients
     try:
-        enabled_sub_agents = [p.name for p in iter_sub_agent_profiles()]
         llm_clients = build_llm_clients(
             config,
             model_override=init_config.model,
-            enabled_sub_agents=enabled_sub_agents,
         )
     except ValueError as exc:
         if init_config.model:
@@ -207,12 +203,14 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
     components = await initialize_app_components(init_config)
 
     try:
-        # Generate a new session ID for exec mode
-        session_id = uuid.uuid4().hex
-
-        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id, is_new_session=True))
+        # Initialize a new session (session_id=None means create new)
+        await components.executor.submit_and_wait(op.InitAgentOperation())
         await components.event_queue.join()
 
+        # Get the session_id from the newly created agent
+        session_ids = components.executor.context.agent_manager.active_session_ids()
+        session_id = session_ids[0] if session_ids else None
+
         # Submit the input content directly
         await components.executor.submit_and_wait(
             op.UserInputOperation(input=UserInputPayload(text=input_content), session_id=session_id)
@@ -224,11 +222,12 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
         await cleanup_app_components(components)
 
 
-async def run_interactive(
-    init_config: AppInitConfig, session_id: str | None = None, *, is_new_session: bool = False
-) -> None:
-    """Run the interactive REPL using the provided configuration."""
+async def run_interactive(init_config: AppInitConfig, session_id: str | None = None) -> None:
+    """Run the interactive REPL using the provided configuration.
 
+    If session_id is None, a new session is created with an auto-generated ID.
+    If session_id is provided, attempts to resume that session.
+    """
     components = await initialize_app_components(init_config)
 
     # No theme persistence from CLI anymore; config.theme controls theme when set.
@@ -236,8 +235,10 @@ async def run_interactive(
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
         agent: Agent | None = None
-        if session_id and session_id in components.executor.context.active_agents:
-            agent = components.executor.context.active_agents[session_id]
+        # Get the first active agent (there should only be one in interactive mode)
+        active_agents = components.executor.context.active_agents
+        if active_agents:
+            agent = next(iter(active_agents.values()), None)
 
         # Check for updates (returns None if uv not available)
         update_message = get_update_message()
@@ -279,10 +280,13 @@ async def run_interactive(
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        await components.executor.submit_and_wait(
-            op.InitAgentOperation(session_id=session_id, is_new_session=is_new_session)
-        )
+        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
         await components.event_queue.join()
+
+        # Get the actual session_id (may have been auto-generated if None was passed)
+        active_session_ids = components.executor.context.agent_manager.active_session_ids()
+        active_session_id = active_session_ids[0] if active_session_ids else session_id
+
         # Input
         await input_provider.start()
         async for user_input in input_provider.iter_inputs():
@@ -293,7 +297,7 @@ async def run_interactive(
                 continue
             # Submit user input operation - directly use the payload from iter_inputs
             submission_id = await components.executor.submit(
-                op.UserInputOperation(input=user_input, session_id=session_id)
+                op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
             # If it's an interactive command (e.g., /model), avoid starting the ESC monitor
             # to prevent TTY conflicts with interactive prompts (questionary/prompt_toolkit).
@@ -302,7 +306,7 @@ async def run_interactive(
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
-                    await components.executor.submit(op.InterruptOperation(target_session_id=session_id))
+                    await components.executor.submit(op.InterruptOperation(target_session_id=active_session_id))
 
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input

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),
+                    ),
+                )
+            ]
+        )