klaude-code 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

klaude_code/protocol/sub_agent/__init__.py

@@ -9,9 +9,11 @@ from klaude_code.protocol import tools
 if TYPE_CHECKING:
     from klaude_code.protocol import model
 
-AvailabilityPredicate = Callable[[str], bool]
 PromptBuilder = Callable[[dict[str, Any]], str]
 
+# Availability requirement constants
+AVAILABILITY_IMAGE_MODEL = "image_model"
+
 
 @dataclass
 class SubAgentResult:
@@ -58,17 +60,13 @@ class SubAgentProfile:
     # Availability
     enabled_by_default: bool = True
     show_in_main_agent: bool = True
-    target_model_filter: AvailabilityPredicate | None = None
 
     # Structured output support: specifies which parameter in the tool schema contains the output schema
     output_schema_arg: str | None = None
 
-    def enabled_for_model(self, model_name: str | None) -> bool:
-        if not self.enabled_by_default:
-            return False
-        if model_name is None or self.target_model_filter is None:
-            return True
-        return self.target_model_filter(model_name)
+    # Config-based availability requirement (e.g., "image_model" means requires an image model)
+    # The actual check is performed in the core layer to avoid circular imports.
+    availability_requirement: str | None = None
 
 
 _PROFILES: dict[str, SubAgentProfile] = {}
@@ -87,11 +85,11 @@ def get_sub_agent_profile(sub_agent_type: tools.SubAgentType) -> SubAgentProfile
         raise KeyError(f"Unknown sub agent type: {sub_agent_type}") from exc
 
 
-def iter_sub_agent_profiles(enabled_only: bool = False, model_name: str | None = None) -> list[SubAgentProfile]:
+def iter_sub_agent_profiles(enabled_only: bool = False) -> list[SubAgentProfile]:
     profiles = list(_PROFILES.values())
     if not enabled_only:
         return profiles
-    return [p for p in profiles if p.enabled_for_model(model_name)]
+    return [p for p in profiles if p.enabled_by_default]
 
 
 def get_sub_agent_profile_by_tool(tool_name: str) -> SubAgentProfile | None:
@@ -102,11 +100,9 @@ def is_sub_agent_tool(tool_name: str) -> bool:
     return tool_name in _PROFILES
 
 
-def sub_agent_tool_names(enabled_only: bool = False, model_name: str | None = None) -> list[str]:
+def sub_agent_tool_names(enabled_only: bool = False) -> list[str]:
     return [
-        profile.name
-        for profile in iter_sub_agent_profiles(enabled_only=enabled_only, model_name=model_name)
-        if profile.show_in_main_agent
+        profile.name for profile in iter_sub_agent_profiles(enabled_only=enabled_only) if profile.show_in_main_agent
     ]
 
 

klaude_code/protocol/sub_agent/image_gen.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, cast
 
-from klaude_code.protocol.sub_agent import SubAgentProfile, register_sub_agent
+from klaude_code.protocol.sub_agent import AVAILABILITY_IMAGE_MODEL, SubAgentProfile, register_sub_agent
 
 IMAGE_GEN_DESCRIPTION = """\
 Generate one or more images from a text prompt.
@@ -115,5 +115,6 @@ register_sub_agent(
         tool_set=(),
         prompt_builder=_build_image_gen_prompt,
         active_form="Generating Image",
+        availability_requirement=AVAILABILITY_IMAGE_MODEL,
     )
 )

klaude_code/session/codec.py

@@ -1,17 +1,13 @@
 from __future__ import annotations
 
 import json
-from typing import Any, TypeGuard, cast, get_args
+from typing import Any, cast, get_args
 
 from pydantic import BaseModel
 
 from klaude_code.protocol import message
 
 
-def _is_basemodel_subclass(tp: object) -> TypeGuard[type[BaseModel]]:
-    return isinstance(tp, type) and issubclass(tp, BaseModel)
-
-
 def _flatten_union(tp: object) -> list[object]:
     args = list(get_args(tp))
     if not args:
@@ -25,7 +21,7 @@ def _flatten_union(tp: object) -> list[object]:
 def _build_type_registry() -> dict[str, type[BaseModel]]:
     registry: dict[str, type[BaseModel]] = {}
     for tp in _flatten_union(message.HistoryEvent):
-        if not _is_basemodel_subclass(tp):
+        if not isinstance(tp, type) or not issubclass(tp, BaseModel):
             continue
         registry[tp.__name__] = tp
     return registry

klaude_code/session/session.py

@@ -370,8 +370,16 @@ class Session(BaseModel):
 
         has_structured_output = report_back_result is not None
         task_result = report_back_result if has_structured_output else last_assistant_content
+
+        if self.sub_agent_state is not None:
+            trimmed = (task_result or "").rstrip()
+            lines = trimmed.splitlines()
+            if not (lines and lines[-1].startswith("agentId:")):
+                footer = f"agentId: {self.id} (for resuming to continue this agent's work if needed)"
+                task_result = f"{trimmed}\n\n{footer}" if trimmed.strip() else footer
+
         yield events.TaskFinishEvent(
-            session_id=self.id, task_result=task_result, has_structured_output=has_structured_output
+            session_id=self.id, task_result=task_result or "", has_structured_output=has_structured_output
         )
 
     def _iter_sub_agent_history(

klaude_code/skill/assets/create-plan/SKILL.md

@@ -13,6 +13,8 @@ Turn a user prompt into a **single, actionable plan** delivered in the final ass
 
 ## Minimal workflow
 
+Throughout the entire workflow, operate in read-only mode. Do not write or update files.
+
 1. **Scan context quickly**
    - Read `README.md` and any obvious docs (`docs/`, `CONTRIBUTING.md`, `ARCHITECTURE.md`).
    - Skim relevant files (the ones most likely touched).
@@ -33,11 +35,7 @@ Turn a user prompt into a **single, actionable plan** delivered in the final ass
    - Include at least one item for **tests/validation** and one for **edge cases/risk** when applicable.
    - If there are unknowns, include a tiny **Open questions** section (max 3).
 
-4. **Write the plan to `plan.md` in the current working directory**
-   - Use the Write tool to save the plan to `./plan.md`
-   - If `plan.md` already exists, overwrite it with the new plan
-
-5. **Do not preface the plan with meta explanations; output only the plan as per template**
+4. **Do not preface the plan with meta explanations; output only the plan as per template**
 
 ## Plan template (follow exactly)
 

klaude_code/tui/command/__init__.py

@@ -35,28 +35,26 @@ def ensure_commands_loaded() -> None:
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
     from .fork_session_cmd import ForkSessionCommand
-    from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
-    from .release_notes_cmd import ReleaseNotesCommand
     from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
+    from .sub_agent_model_cmd import SubAgentModelCommand
     from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
+    register(CopyCommand())
     register(ExportCommand())
-    register(ExportOnlineCommand())
     register(RefreshTerminalCommand())
-    register(ThinkingCommand())
     register(ModelCommand())
-    register(CopyCommand())
+    register(SubAgentModelCommand())
+    register(ThinkingCommand())
     register(ForkSessionCommand())
-    register(ResumeCommand())
     load_prompt_commands()
     register(StatusCommand())
-    register(HelpCommand())
-    register(ReleaseNotesCommand())
+    register(ResumeCommand())
+    register(ExportOnlineCommand())
     register(TerminalSetupCommand())
     register(DebugCommand())
     register(ClearCommand())
@@ -73,12 +71,11 @@ def __getattr__(name: str) -> object:
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",
         "ForkSessionCommand": "fork_session_cmd",
-        "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",
-        "ReleaseNotesCommand": "release_notes_cmd",
         "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
+        "SubAgentModelCommand": "sub_agent_model_cmd",
         "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",
     }

klaude_code/tui/command/clear_cmd.py

@@ -22,5 +22,5 @@ class ClearCommand(CommandABC):
 
         return CommandResult(
             operations=[op.ClearSessionOperation(session_id=agent.session.id)],
-            persist_user_input=False,
+            persist=False,
         )

klaude_code/tui/command/command_abc.py

@@ -43,8 +43,7 @@ class CommandResult(BaseModel):
     operations: list[op.Operation] | None = None
 
     # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
-    persist_user_input: bool = True
-    persist_events: bool = True
+    persist: bool = True
 
 
 class CommandABC(ABC):

klaude_code/tui/command/copy_cmd.py

@@ -48,6 +48,5 @@ def _developer_message(agent: Agent, content: str, command_name: commands.Comman
                 ),
             )
         ],
-        persist_user_input=False,
-        persist_events=False,
+        persist=False,
     )

klaude_code/tui/command/fork_session_cmd.py

@@ -211,7 +211,7 @@ class ForkSessionCommand(CommandABC):
                     ui_extra=model.build_command_output_extra(self.name),
                 ),
             )
-            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+            return CommandResult(events=[event], persist=False)
 
         # Build fork points from conversation history
         fork_points = _build_fork_points(agent.session.conversation_history)
@@ -234,7 +234,7 @@ class ForkSessionCommand(CommandABC):
                     ),
                 ),
             )
-            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+            return CommandResult(events=[event], persist=False)
 
         # Interactive selection
         selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
@@ -247,7 +247,7 @@ class ForkSessionCommand(CommandABC):
                     ui_extra=model.build_command_output_extra(self.name),
                 ),
             )
-            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+            return CommandResult(events=[event], persist=False)
 
         # Perform the fork
         new_session = agent.session.fork(until_index=selected)
@@ -271,4 +271,4 @@ class ForkSessionCommand(CommandABC):
                 ),
             ),
         )
-        return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+        return CommandResult(events=[event], persist=False)

klaude_code/tui/command/model_cmd.py

@@ -1,46 +1,9 @@
 import asyncio
 
-from prompt_toolkit.styles import Style
-
 from klaude_code.protocol import commands, events, message, model, op
-from klaude_code.tui.terminal.selector import SelectItem, select_one
 
 from .command_abc import Agent, CommandABC, CommandResult
-from .model_select import select_model_interactive
-
-SELECT_STYLE = Style(
-    [
-        ("instruction", "ansibrightblack"),
-        ("pointer", "ansigreen"),
-        ("highlighted", "ansigreen"),
-        ("text", "ansibrightblack"),
-        ("question", "bold"),
-    ]
-)
-
-
-def _confirm_change_default_model_sync(selected_model: str) -> bool:
-    items: list[SelectItem[bool]] = [
-        SelectItem(title=[("class:text", "No  (session only)\n")], value=False, search_text="No"),
-        SelectItem(
-            title=[("class:text", "Yes (save as default main_model in ~/.klaude/klaude-config.yaml)\n")],
-            value=True,
-            search_text="Yes",
-        ),
-    ]
-
-    try:
-        result = select_one(
-            message=f"Save '{selected_model}' as default model?",
-            items=items,
-            pointer="→",
-            style=SELECT_STYLE,
-            use_search_filter=False,
-        )
-    except KeyboardInterrupt:
-        return False
-
-    return bool(result)
+from .model_select import ModelSelectStatus, select_model_interactive
 
 
 class ModelCommand(CommandABC):
@@ -52,7 +15,7 @@ class ModelCommand(CommandABC):
 
     @property
     def summary(self) -> str:
-        return "Select and switch LLM"
+        return "Change model (saves to config)"
 
     @property
     def is_interactive(self) -> bool:
@@ -67,9 +30,10 @@ class ModelCommand(CommandABC):
         return "model name"
 
     async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
-        selected_model = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
+        model_result = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
 
-        current_model = agent.profile.llm_client.model_name if agent.profile else None
+        current_model = agent.session.model_config_name
+        selected_model = model_result.model if model_result.status == ModelSelectStatus.SELECTED else None
         if selected_model is None or selected_model == current_model:
             return CommandResult(
                 events=[
@@ -82,13 +46,12 @@ class ModelCommand(CommandABC):
                     )
                 ]
             )
-        save_as_default = await asyncio.to_thread(_confirm_change_default_model_sync, selected_model)
         return CommandResult(
             operations=[
                 op.ChangeModelOperation(
                     session_id=agent.session.id,
                     model_name=selected_model,
-                    save_as_default=save_as_default,
+                    save_as_default=True,
                 )
             ]
         )

klaude_code/tui/command/model_select.py

@@ -1,58 +1,107 @@
 """Interactive model selection for CLI."""
 
+from __future__ import annotations
+
 import sys
+from dataclasses import dataclass
+from enum import Enum
 
 from klaude_code.config.config import load_config
 from klaude_code.config.select_model import match_model_from_config
 from klaude_code.log import log
 
 
-def select_model_interactive(preferred: str | None = None) -> str | None:
+class ModelSelectStatus(Enum):
+    SELECTED = "selected"
+    CANCELLED = "cancelled"
+    NO_MATCH = "no_match"
+    NO_MODELS = "no_models"
+    NON_TTY = "non_tty"
+    ERROR = "error"
+
+
+@dataclass
+class ModelSelectResult:
+    status: ModelSelectStatus
+    model: str | None = None
+
+
+def select_model_interactive(
+    preferred: str | None = None,
+    keywords: list[str] | None = None,
+) -> ModelSelectResult:
     """Interactive single-choice model selector.
 
     This function combines matching logic with interactive UI selection.
     For CLI usage.
 
+    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_params.model.
+
     If preferred is provided:
     - Exact match: return immediately
     - Single partial match (case-insensitive): return immediately
     - Otherwise: fall through to interactive selection
     """
-    result = match_model_from_config(preferred)
+    config = load_config()
+    result = match_model_from_config(None if keywords else preferred)
 
     if result.error_message:
-        return None
+        return ModelSelectResult(status=ModelSelectStatus.NO_MODELS)
 
     if result.matched_model:
-        return result.matched_model
+        return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=result.matched_model)
+
+    if keywords:
+        keywords_lower = [k.lower() for k in keywords]
+        filtered_models = [
+            m
+            for m in result.filtered_models
+            if any(kw in (m.model_params.model or "").lower() for kw in keywords_lower)
+        ]
+        if not filtered_models:
+            return ModelSelectResult(status=ModelSelectStatus.NO_MATCH)
+        result.filtered_models = filtered_models
+        result.filter_hint = ", ".join(keywords)
+        result.matched_model = 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:
+        if preferred and not keywords:
             log((f"Hint: '{preferred}' did not resolve to a single configured model", "yellow"))
-        return None
+        return ModelSelectResult(status=ModelSelectStatus.NON_TTY)
 
     # Interactive selection
     from prompt_toolkit.styles import Style
 
     from klaude_code.tui.terminal.selector import build_model_select_items, select_one
 
-    config = load_config()
-    names = [m.model_name for m in result.filtered_models]
+    names = [m.selector for m in result.filtered_models]
 
     try:
         items = build_model_select_items(result.filtered_models)
 
         message = f"Select a model (filtered by '{result.filter_hint}'):" if result.filter_hint else "Select a model:"
+
+        initial_value = config.main_model
+        if isinstance(initial_value, str) and initial_value and "@" not in initial_value:
+            try:
+                resolved = config.resolve_model_location_prefer_available(
+                    initial_value
+                ) or config.resolve_model_location(initial_value)
+            except ValueError:
+                resolved = None
+            if resolved is not None:
+                initial_value = f"{resolved[0]}@{resolved[1]}"
+
         selected = select_one(
             message=message,
             items=items,
             pointer="→",
             use_search_filter=True,
-            initial_value=config.main_model,
+            initial_value=initial_value,
             style=Style(
                 [
                     ("pointer", "ansigreen"),
@@ -69,16 +118,27 @@ def select_model_interactive(preferred: str | None = None) -> str | None:
             ),
         )
         if isinstance(selected, str) and selected in names:
-            return selected
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=selected)
     except KeyboardInterrupt:
-        return None
+        return ModelSelectResult(status=ModelSelectStatus.CANCELLED)
     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 result.matched_model and result.matched_model in names:
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=result.matched_model)
         if config.main_model and config.main_model in names:
-            return config.main_model
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=config.main_model)
+        if config.main_model and "@" not in config.main_model:
+            try:
+                resolved = config.resolve_model_location_prefer_available(
+                    config.main_model
+                ) or config.resolve_model_location(config.main_model)
+            except ValueError:
+                resolved = None
+            if resolved is not None:
+                selector = f"{resolved[0]}@{resolved[1]}"
+                if selector in names:
+                    return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=selector)
 
-    return None
+    return ModelSelectResult(status=ModelSelectStatus.ERROR)

klaude_code/tui/command/refresh_cmd.py

@@ -38,6 +38,5 @@ class RefreshTerminalCommand(CommandABC):
                     is_load=False,
                 ),
             ],
-            persist_user_input=False,
-            persist_events=False,
+            persist=False,
         )

klaude_code/tui/command/resume_cmd.py

@@ -96,7 +96,7 @@ class ResumeCommand(CommandABC):
                     ui_extra=model.build_command_output_extra(self.name, is_error=True),
                 ),
             )
-            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+            return CommandResult(events=[event], persist=False)
 
         selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
@@ -107,10 +107,9 @@ class ResumeCommand(CommandABC):
                     ui_extra=model.build_command_output_extra(self.name),
                 ),
             )
-            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+            return CommandResult(events=[event], persist=False)
 
         return CommandResult(
             operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
-            persist_user_input=False,
-            persist_events=False,
+            persist=False,
         )

klaude_code/tui/command/status_cmd.py

@@ -153,4 +153,4 @@ class StatusCommand(CommandABC):
             ),
         )
 
-        return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+        return CommandResult(events=[event], persist=False)