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

klaude_code/command/thinking_cmd.py

@@ -1,171 +1,37 @@
 import asyncio
-from typing import Literal, cast
 
 from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events, llm_param, model
+from klaude_code.config.thinking import get_thinking_picker_data, parse_thinking_value
+from klaude_code.protocol import commands, events, llm_param, model, op
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
-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"
-
-
 SELECT_STYLE = Style(
     [
         ("instruction", "ansibrightblack"),
         ("pointer", "ansigreen"),
         ("highlighted", "ansigreen"),
         ("text", "ansibrightblack"),
-        ("question", ""),
+        ("question", "bold"),
     ]
 )
 
 
-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)
-    items: list[SelectItem[str]] = [
-        SelectItem(title=[("class:text", level + "\n")], value=level, search_text=level) for level in levels
-    ]
-
-    try:
-        result = select_one(
-            message="Select reasoning effort:",
-            items=items,
-            pointer="→",
-            style=SELECT_STYLE,
-            use_search_filter=False,
-        )
-
-        if result is None:
-            return None
-        return llm_param.Thinking(reasoning_effort=cast(ReasoningEffort, result))
-    except KeyboardInterrupt:
+def _select_thinking_sync(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking level (sync version)."""
+    data = get_thinking_picker_data(config)
+    if data is None:
         return None
 
-
-def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
-    """Select thinking level for anthropic/openai_compatible protocol (sync version)."""
-    items: list[SelectItem[int]] = [
-        SelectItem(title=[("class:text", label + "\n")], value=tokens or 0, search_text=label)
-        for label, tokens in ANTHROPIC_LEVELS
+    items: list[SelectItem[str]] = [
+        SelectItem(title=[("class:text", opt.label + "\n")], value=opt.value, search_text=opt.label)
+        for opt in data.options
     ]
 
     try:
         result = select_one(
-            message="Select thinking level:",
+            message=data.message,
             items=items,
             pointer="→",
             style=SELECT_STYLE,
@@ -173,9 +39,7 @@ def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
         )
         if result is None:
             return None
-        if result == 0:
-            return llm_param.Thinking(type="disabled", budget_tokens=0)
-        return llm_param.Thinking(type="enabled", budget_tokens=result)
+        return parse_thinking_value(result)
     except KeyboardInterrupt:
         return None
 
@@ -185,24 +49,7 @@ async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) ->
 
     Returns the selected Thinking config, or None if user cancelled.
     """
-    protocol = config.protocol
-    model_name = config.model
-
-    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-        return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        if _is_openrouter_model_with_reasoning_effort(model_name):
-            return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    if protocol == llm_param.LLMClientProtocol.OPENAI:
-        return await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-    return None
+    return await asyncio.to_thread(_select_thinking_sync, config)
 
 
 class ThinkingCommand(CommandABC):
@@ -222,46 +69,30 @@ class ThinkingCommand(CommandABC):
 
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
-        if not agent.profile:
-            return self._no_change_result(agent, "No profile configured")
+        if agent.profile is None:
+            return CommandResult(events=[])
 
         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:
-            return self._no_change_result(agent, "(no change)")
 
-        # Apply the new thinking configuration
-        config.thinking = new_thinking
-        agent.session.model_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),
-                    ),
-                ),
-                events.WelcomeEvent(
-                    work_dir=str(agent.session.work_dir),
-                    llm_config=config,
-                ),
-            ]
-        )
+        if new_thinking is None:
+            return CommandResult(
+                events=[
+                    events.DeveloperMessageEvent(
+                        session_id=agent.session.id,
+                        item=model.DeveloperMessageItem(
+                            content="(no change)",
+                            command_output=model.CommandOutput(command_name=self.name),
+                        ),
+                    )
+                ]
+            )
 
-    def _no_change_result(self, agent: "Agent", message: str) -> CommandResult:
         return CommandResult(
-            events=[
-                events.DeveloperMessageEvent(
+            operations=[
+                op.ChangeThinkingOperation(
                     session_id=agent.session.id,
-                    item=model.DeveloperMessageItem(
-                        content=message,
-                        command_output=model.CommandOutput(command_name=self.name),
-                    ),
+                    thinking=new_thinking,
                 )
             ]
         )

klaude_code/config/select_model.py

@@ -1,4 +1,4 @@
-import sys
+from dataclasses import dataclass
 
 from klaude_code.config.config import ModelEntry, load_config, print_no_available_models_hint
 from klaude_code.trace import log
@@ -17,15 +17,34 @@ def _normalize_model_key(value: str) -> str:
     return "".join(ch for ch in value.casefold() if ch.isalnum())
 
 
-def select_model_from_config(preferred: str | None = None) -> str | None:
+@dataclass
+class ModelMatchResult:
+    """Result of model matching.
+
+    Attributes:
+        matched_model: The single matched model name, or None if ambiguous/no match.
+        filtered_models: List of filtered models for interactive selection.
+        filter_hint: The filter hint to show (original preferred value), or None.
+        error_message: Error message if no models available, or None.
     """
-    Interactive single-choice model selector.
-    for `--select-model`
+
+    matched_model: str | None
+    filtered_models: list[ModelEntry]
+    filter_hint: str | None
+    error_message: str | None = None
+
+
+def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
+    """Match model from config without interactive selection.
 
     If preferred is provided:
-    - Exact match: return immediately
-    - Single partial match (case-insensitive): return immediately
-    - Otherwise: fall through to interactive selection
+    - Exact match: returns matched_model
+    - Single partial match (case-insensitive): returns matched_model
+    - Multiple matches: returns filtered_models for interactive selection
+    - No matches: returns all models with filter_hint=None
+
+    Returns:
+        ModelMatchResult with match state.
     """
     config = load_config()
 
@@ -36,17 +55,22 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
 
     if not models:
         print_no_available_models_hint()
-        return None
+        return ModelMatchResult(
+            matched_model=None,
+            filtered_models=[],
+            filter_hint=None,
+            error_message="No models available",
+        )
 
     names: list[str] = [m.model_name for m in models]
 
     # Try to match preferred model name
-    filtered_models = models
+    filter_hint = preferred
     if preferred and preferred.strip():
         preferred = preferred.strip()
         # Exact match
         if preferred in names:
-            return preferred
+            return ModelMatchResult(matched_model=preferred, filtered_models=models, filter_hint=None)
 
         preferred_lower = preferred.lower()
         # Case-insensitive exact match (model_name or model_params.model)
@@ -56,7 +80,9 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
             if preferred_lower == m.model_name.lower() or preferred_lower == (m.model_params.model or "").lower()
         ]
         if len(exact_ci_matches) == 1:
-            return exact_ci_matches[0].model_name
+            return ModelMatchResult(
+                matched_model=exact_ci_matches[0].model_name, filtered_models=models, filter_hint=None
+            )
 
         # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
         preferred_norm = _normalize_model_key(preferred)
@@ -69,7 +95,9 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
                 or preferred_norm == _normalize_model_key(m.model_params.model or "")
             ]
             if len(normalized_matches) == 1:
-                return normalized_matches[0].model_name
+                return ModelMatchResult(
+                    matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                )
 
             if not normalized_matches and len(preferred_norm) >= 4:
                 normalized_matches = [
@@ -79,7 +107,9 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
                     or preferred_norm in _normalize_model_key(m.model_params.model or "")
                 ]
                 if len(normalized_matches) == 1:
-                    return normalized_matches[0].model_name
+                    return ModelMatchResult(
+                        matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                    )
 
         # Partial match (case-insensitive) on model_name or model_params.model.
         # If normalized matching found candidates (even if multiple), prefer those as the filter set.
@@ -89,93 +119,13 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
             if preferred_lower in m.model_name.lower() or preferred_lower in (m.model_params.model or "").lower()
         ]
         if len(matches) == 1:
-            return matches[0].model_name
+            return ModelMatchResult(matched_model=matches[0].model_name, filtered_models=models, filter_hint=None)
         if matches:
             # Multiple matches: filter the list for interactive selection
-            filtered_models = matches
+            return ModelMatchResult(matched_model=None, filtered_models=matches, filter_hint=filter_hint)
         else:
             # No matches: show all models without filter hint
-            preferred = None
             log(("No matching models found. Showing all models.", "yellow"))
+            return ModelMatchResult(matched_model=None, filtered_models=models, filter_hint=None)
 
-    # Non-interactive environments (CI/pipes) should never enter an interactive prompt.
-    # If we couldn't resolve to a single model deterministically above, fail with a clear hint.
-    if not sys.stdin.isatty() or not sys.stdout.isatty():
-        log(("Error: cannot use interactive model selection without a TTY", "red"))
-        log(("Hint: pass --model <config-name> or set main_model in ~/.klaude/klaude-config.yaml", "yellow"))
-        if preferred:
-            log((f"Hint: '{preferred}' did not resolve to a single configured model", "yellow"))
-        return None
-
-    try:
-        from prompt_toolkit.styles import Style
-
-        from klaude_code.ui.terminal.selector import SelectItem, select_one
-
-        max_model_name_length = max(len(m.model_name) for m in filtered_models)
-
-        def _thinking_info(m: ModelEntry) -> str:
-            thinking = m.model_params.thinking
-            if not thinking:
-                return ""
-            if thinking.reasoning_effort:
-                return f"reasoning {thinking.reasoning_effort}"
-            if thinking.budget_tokens:
-                return f"thinking budget {thinking.budget_tokens}"
-            return "thinking (configured)"
-
-        items: list[SelectItem[str]] = []
-        for m in filtered_models:
-            model_id = m.model_params.model or "N/A"
-            first_line_prefix = f"{m.model_name:<{max_model_name_length}} → "
-            thinking_info = _thinking_info(m)
-            meta_parts: list[str] = [m.provider]
-            if thinking_info:
-                meta_parts.append(thinking_info)
-            if m.model_params.verbosity:
-                meta_parts.append(f"verbosity {m.model_params.verbosity}")
-            meta_str = " · ".join(meta_parts)
-            title = [
-                ("class:msg", first_line_prefix),
-                ("class:msg bold", model_id),
-                ("class:meta", f"  {meta_str}\n"),
-            ]
-            search_text = f"{m.model_name} {model_id} {m.provider}"
-            items.append(SelectItem(title=title, value=m.model_name, search_text=search_text))
-
-        try:
-            message = f"Select a model (filtered by '{preferred}'):" if preferred else "Select a model:"
-            result = select_one(
-                message=message,
-                items=items,
-                pointer="→",
-                use_search_filter=True,
-                initial_value=config.main_model,
-                style=Style(
-                    [
-                        ("pointer", "ansigreen"),
-                        ("highlighted", "ansigreen"),
-                        ("msg", ""),
-                        ("meta", "fg:ansibrightblack"),
-                        ("text", "ansibrightblack"),
-                        ("question", "bold"),
-                        ("search_prefix", "ansibrightblack"),
-                        # search filter colors at the bottom
-                        ("search_success", "noinherit fg:ansigreen"),
-                        ("search_none", "noinherit fg:ansired"),
-                    ]
-                ),
-            )
-            if isinstance(result, str) and result in names:
-                return result
-        except KeyboardInterrupt:
-            return None
-    except Exception as e:
-        log((f"Failed to use prompt_toolkit for model selection: {e}", "yellow"))
-        # Never return an unvalidated model name here.
-        # If we can't interactively select, fall back to a known configured model.
-        if isinstance(preferred, str) and preferred in names:
-            return preferred
-        if config.main_model and config.main_model in names:
-            return config.main_model
-        return None
+    return ModelMatchResult(matched_model=None, filtered_models=models, filter_hint=None)