klaude-code 1.4.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

klaude_code/config/thinking.py

@@ -0,0 +1,255 @@
+"""Thinking level configuration data and helpers.
+
+This module contains thinking level definitions and helper functions
+that are shared between command layer and UI layer.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from klaude_code.protocol import llm_param
+
+ReasoningEffort = Literal["high", "medium", "low", "minimal", "none", "xhigh"]
+
+# Thinking level options for different protocols
+RESPONSES_LEVELS = ["low", "medium", "high"]
+RESPONSES_GPT51_LEVELS = ["none", "low", "medium", "high"]
+RESPONSES_GPT52_LEVELS = ["none", "low", "medium", "high", "xhigh"]
+RESPONSES_CODEX_MAX_LEVELS = ["medium", "high", "xhigh"]
+RESPONSES_GEMINI_FLASH_LEVELS = ["minimal", "low", "medium", "high"]
+
+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 ["gpt-5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
+
+
+def _is_gpt52_model(model_name: str | None) -> bool:
+    """Check if the model is GPT-5.2."""
+    if not model_name:
+        return False
+    return model_name.lower() in ["gpt-5.2", "openai/gpt-5.2"]
+
+
+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 _is_gemini_flash_model(model_name: str | None) -> bool:
+    """Check if the model is Gemini 3 Flash."""
+    if not model_name:
+        return False
+    return "gemini-3-flash" in model_name.lower()
+
+
+def should_auto_trigger_thinking(model_name: str | None) -> bool:
+    """Check if model should auto-trigger thinking selection on switch."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_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_gpt52_model(model_name):
+        return RESPONSES_GPT52_LEVELS
+    if _is_gpt51_model(model_name):
+        return RESPONSES_GPT51_LEVELS
+    if _is_gemini_flash_model(model_name):
+        return RESPONSES_GEMINI_FLASH_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"
+
+
+# ---------------------------------------------------------------------------
+# Thinking picker data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ThinkingOption:
+    """A thinking option for selection.
+
+    Attributes:
+        label: Display label for this option (e.g., "low", "medium (8192 tokens)").
+        value: Encoded value string (e.g., "effort:low", "budget:2048").
+    """
+
+    label: str
+    value: str
+
+
+@dataclass
+class ThinkingPickerData:
+    """Data for building thinking picker UI.
+
+    Attributes:
+        options: List of thinking options.
+        message: Prompt message (e.g., "Select reasoning effort:").
+        current_value: Currently selected value, or None.
+    """
+
+    options: list[ThinkingOption]
+    message: str
+    current_value: str | None
+
+
+def _build_effort_options(levels: list[str]) -> list[ThinkingOption]:
+    """Build effort-based thinking options."""
+    return [ThinkingOption(label=level, value=f"effort:{level}") for level in levels]
+
+
+def _build_budget_options() -> list[ThinkingOption]:
+    """Build budget-based thinking options."""
+    return [ThinkingOption(label=label, value=f"budget:{tokens or 0}") for label, tokens in ANTHROPIC_LEVELS]
+
+
+def _get_current_effort_value(thinking: llm_param.Thinking | None) -> str | None:
+    """Get current value for effort-based thinking."""
+    if thinking and thinking.reasoning_effort:
+        return f"effort:{thinking.reasoning_effort}"
+    return None
+
+
+def _get_current_budget_value(thinking: llm_param.Thinking | None) -> str | None:
+    """Get current value for budget-based thinking."""
+    if thinking:
+        if thinking.type == "disabled":
+            return "budget:0"
+        if thinking.budget_tokens:
+            return f"budget:{thinking.budget_tokens}"
+    return None
+
+
+def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPickerData | None:
+    """Get thinking picker data based on LLM config.
+
+    Returns:
+        ThinkingPickerData with options and current value, or None if protocol doesn't support thinking.
+    """
+    protocol = config.protocol
+    model_name = config.model
+    thinking = config.thinking
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        levels = get_levels_for_responses(model_name)
+        return ThinkingPickerData(
+            options=_build_effort_options(levels),
+            message="Select reasoning effort:",
+            current_value=_get_current_effort_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if is_openrouter_model_with_reasoning_effort(model_name):
+            levels = get_levels_for_responses(model_name)
+            return ThinkingPickerData(
+                options=_build_effort_options(levels),
+                message="Select reasoning effort:",
+                current_value=_get_current_effort_value(thinking),
+            )
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
+    return None
+
+
+def parse_thinking_value(value: str) -> llm_param.Thinking | None:
+    """Parse a thinking value string into a Thinking object.
+
+    Args:
+        value: Encoded value string (e.g., "effort:low", "budget:2048").
+
+    Returns:
+        Thinking object, or None if invalid format.
+    """
+    if value.startswith("effort:"):
+        effort = value[7:]
+        return llm_param.Thinking(reasoning_effort=effort)  # type: ignore[arg-type]
+
+    if value.startswith("budget:"):
+        budget = int(value[7:])
+        if budget == 0:
+            return llm_param.Thinking(type="disabled", budget_tokens=0)
+        return llm_param.Thinking(type="enabled", budget_tokens=budget)
+
+    return None

klaude_code/core/executor.py

@@ -13,18 +13,13 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
-from klaude_code.command import dispatch_command
-from klaude_code.command.thinking_cmd import (
-    format_current_thinking,
-    select_thinking_for_protocol,
-    should_auto_trigger_thinking,
-)
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.core.tool import current_run_subtask_callback
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.export import build_export_html, get_default_export_path
@@ -181,7 +176,11 @@ class ExecutorContext:
         await self._ensure_agent(operation.session_id)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
-        """Handle a user input operation by dispatching it into operations."""
+        """Handle a user input operation.
+
+        Core should not parse slash commands. The UI/CLI layer is responsible for
+        turning raw user input into one or more operations.
+        """
 
         if operation.session_id is None:
             raise ValueError("session_id cannot be None")
@@ -190,33 +189,18 @@ class ExecutorContext:
         agent = await self._ensure_agent(session_id)
         user_input = operation.input
 
-        # Emit the original user input to UI (even if the persisted text differs).
         await self.emit_event(
             events.UserMessageEvent(content=user_input.text, session_id=session_id, images=user_input.images)
         )
+        agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
 
-        result = await dispatch_command(user_input, agent, submission_id=operation.id)
-        ops: list[op.Operation] = list(result.operations or [])
-
-        run_ops = [candidate for candidate in ops if isinstance(candidate, op.RunAgentOperation)]
-        if len(run_ops) > 1:
-            raise ValueError("Multiple RunAgentOperation results are not supported")
-
-        persisted_user_input = run_ops[0].input if run_ops else user_input
-
-        if result.persist_user_input:
-            agent.session.append_history(
-                [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
+        await self.handle_run_agent(
+            op.RunAgentOperation(
+                id=operation.id,
+                session_id=session_id,
+                input=user_input,
             )
-
-        if result.events:
-            for evt in result.events:
-                if result.persist_events and isinstance(evt, events.DeveloperMessageEvent):
-                    agent.session.append_history([evt.item])
-                await self.emit_event(evt)
-
-        for operation_item in ops:
-            await operation_item.execute(handler=self)
+        )
 
     async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
@@ -243,56 +227,62 @@ class ExecutorContext:
             config.main_model = operation.model_name
             await config.save()
 
-        default_note = " (saved as default)" if operation.save_as_default else ""
-        developer_item = model.DeveloperMessageItem(
-            content=f"Switched to: {llm_config.model}{default_note}",
-            command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
-        )
-        agent.session.append_history([developer_item])
-
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        if operation.emit_switch_message:
+            default_note = " (saved as default)" if operation.save_as_default else ""
+            developer_item = model.DeveloperMessageItem(
+                content=f"Switched to: {llm_config.model}{default_note}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
         if self._on_model_change is not None:
             self._on_model_change(llm_client.model_name)
 
-        if should_auto_trigger_thinking(llm_config.model):
-            thinking_op = op.ChangeThinkingOperation(session_id=operation.session_id)
-            await thinking_op.execute(handler=self)
-            # WelcomeEvent is already handled by the thinking change
-        else:
+        if operation.emit_welcome_event:
             await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
     async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
-        """Handle a change thinking operation by prompting user to select thinking level."""
+        """Handle a change thinking operation.
+
+        Interactive thinking selection must happen in the UI/CLI layer. Core only
+        applies a concrete thinking configuration.
+        """
         agent = await self._ensure_agent(operation.session_id)
-        if not agent.profile:
-            return
 
         config = agent.profile.llm_client.get_llm_config()
-        current = format_current_thinking(config)
-
-        new_thinking = await select_thinking_for_protocol(config)
 
-        if new_thinking is None:
+        def _format_thinking_for_display(thinking: Thinking | None) -> str:
+            if thinking is None:
+                return "not configured"
+            if thinking.reasoning_effort:
+                return f"reasoning_effort={thinking.reasoning_effort}"
+            if thinking.type == "disabled":
+                return "off"
+            if thinking.type == "enabled":
+                if thinking.budget_tokens is None:
+                    return "enabled"
+                return f"enabled (budget_tokens={thinking.budget_tokens})"
+            return "not set"
+
+        if operation.thinking is None:
+            raise ValueError("thinking must be provided; interactive selection belongs to UI")
+
+        current = _format_thinking_for_display(config.thinking)
+        config.thinking = operation.thinking
+        agent.session.model_thinking = operation.thinking
+        new_status = _format_thinking_for_display(config.thinking)
+
+        if operation.emit_switch_message:
             developer_item = model.DeveloperMessageItem(
-                content="(thinking unchanged)",
+                content=f"Thinking changed: {current} -> {new_status}",
                 command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
             )
+            agent.session.append_history([developer_item])
             await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-            return
-
-        config.thinking = new_thinking
-        agent.session.model_thinking = new_thinking
-        new_status = format_current_thinking(config)
-
-        developer_item = model.DeveloperMessageItem(
-            content=f"Thinking changed: {current} -> {new_status}",
-            command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
-        )
-        agent.session.append_history([developer_item])
 
-        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+        if operation.emit_welcome_event:
+            await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
 
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)

klaude_code/protocol/commands.py

@@ -1,6 +1,17 @@
+from dataclasses import dataclass
 from enum import Enum
 
 
+@dataclass(frozen=True, slots=True)
+class CommandInfo:
+    """Lightweight command metadata for UI purposes (no logic)."""
+
+    name: str
+    summary: str
+    support_addition_params: bool = False
+    placeholder: str = ""
+
+
 class CommandName(str, Enum):
     INIT = "init"
     DEBUG = "debug"

klaude_code/protocol/op.py

@@ -13,6 +13,7 @@ from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
+from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.model import UserInputPayload
 
 if TYPE_CHECKING:
@@ -75,6 +76,17 @@ class ChangeModelOperation(Operation):
     session_id: str
     model_name: str
     save_as_default: bool = False
+    # When True, the executor must not auto-trigger an interactive thinking selector.
+    # This is required for in-prompt model switching where the terminal is already
+    # controlled by a prompt_toolkit PromptSession.
+    defer_thinking_selection: bool = False
+    # When False, do not emit WelcomeEvent (which renders a banner/panel).
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_welcome_event: bool = True
+
+    # When False, do not emit the "Switched to: ..." developer message.
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_switch_message: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_model(self)
@@ -85,6 +97,9 @@ class ChangeThinkingOperation(Operation):
 
     type: OperationType = OperationType.CHANGE_THINKING
     session_id: str
+    thinking: Thinking | None = None
+    emit_welcome_event: bool = True
+    emit_switch_message: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_change_thinking(self)

klaude_code/session/__init__.py

@@ -1,4 +1,4 @@
-from .selector import resume_select_session
+from .selector import SessionSelectOption, build_session_select_options
 from .session import Session
 
-__all__ = ["Session", "resume_select_session"]
+__all__ = ["Session", "SessionSelectOption", "build_session_select_options"]

klaude_code/session/selector.py

@@ -1,7 +1,5 @@
 import time
-
-from klaude_code.trace import log, log_debug
-from klaude_code.ui.terminal.selector import SelectItem, select_one
+from dataclasses import dataclass
 
 from .session import Session
 
@@ -30,69 +28,43 @@ def _relative_time(ts: float) -> str:
         return f"{months} month{'s' if months != 1 else ''} ago"
 
 
-def resume_select_session() -> str | None:
+@dataclass(frozen=True, slots=True)
+class SessionSelectOption:
+    """Option data for session selection UI."""
+
+    session_id: str
+    first_user_message: str
+    messages_count: str
+    relative_time: str
+    model_name: str
+
+
+def build_session_select_options() -> list[SessionSelectOption]:
+    """Build session selection options data.
+
+    Returns:
+        List of SessionSelectOption, or empty list if no sessions exist.
+    """
     sessions = Session.list_sessions()
     if not sessions:
-        log("No sessions found for this project.")
-        return None
-
-    try:
-        from prompt_toolkit.styles import Style
+        return []
 
-        items: list[SelectItem[str]] = []
-        for s in sessions:
-            first_msg = s.first_user_message or "N/A"
-            first_msg = first_msg.strip().replace("\n", " ")
+    options: list[SessionSelectOption] = []
+    for s in sessions:
+        first_msg = s.first_user_message or "N/A"
+        first_msg = first_msg.strip().replace("\n", " ")
 
-            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
-            model = s.model_name or "N/A"
+        msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
+        model = s.model_name or "N/A"
 
-            title = [
-                ("class:msg", f"{first_msg}\n"),
-                ("class:meta", f"   {msg_count} · {_relative_time(s.updated_at)} · {model} · {s.id}\n\n"),
-            ]
-            items.append(
-                SelectItem(
-                    title=title,
-                    value=str(s.id),
-                    search_text=f"{first_msg} {model} {s.id}",
-                )
+        options.append(
+            SessionSelectOption(
+                session_id=str(s.id),
+                first_user_message=first_msg,
+                messages_count=msg_count,
+                relative_time=_relative_time(s.updated_at),
+                model_name=model,
             )
-
-        return select_one(
-            message="Select a session to resume:",
-            items=items,
-            pointer="→",
-            style=Style(
-                [
-                    ("msg", ""),
-                    ("meta", "fg:ansibrightblack"),
-                    ("pointer", "bold fg:ansigreen"),
-                    ("highlighted", "fg:ansigreen"),
-                    ("search_prefix", "fg:ansibrightblack"),
-                    ("search_success", "noinherit fg:ansigreen"),
-                    ("search_none", "noinherit fg:ansired"),
-                    ("question", "bold"),
-                    ("text", ""),
-                ]
-            ),
         )
-    except Exception as e:
-        log_debug(f"Failed to use prompt_toolkit for session select, {e}")
 
-        for i, s in enumerate(sessions, 1):
-            first_msg = (s.first_user_message or "N/A").strip().replace("\n", " ")
-            if len(first_msg) > 60:
-                first_msg = first_msg[:59] + "…"
-            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} msgs"
-            model = s.model_name or "N/A"
-            print(f"{i}. {first_msg}")
-            print(f"   {_relative_time(s.updated_at)} · {msg_count} · {model}")
-        try:
-            raw = input("Select a session number: ").strip()
-            idx = int(raw)
-            if 1 <= idx <= len(sessions):
-                return str(sessions[idx - 1].id)
-        except (ValueError, EOFError):
-            return None
-    return None
+    return options