klaude-code 1.2.18__py3-none-any.whl → 1.2.20__py3-none-any.whl

klaude_code/command/prompt_command.py

@@ -2,8 +2,8 @@ from importlib.resources import files
 
 import yaml
 
-from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
-from klaude_code.protocol import commands
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, model, op
 from klaude_code.trace import log_debug
 
 
@@ -55,16 +55,23 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
-        user_input = raw.strip() or "<none>"
+        user_input_text = user_input.text.strip() or "<none>"
 
         if "$ARGUMENTS" in template_content:
-            final_prompt = template_content.replace("$ARGUMENTS", user_input)
+            final_prompt = template_content.replace("$ARGUMENTS", user_input_text)
         else:
             final_prompt = template_content
-            if user_input:
-                final_prompt += f"\n\nAdditional Instructions:\n{user_input}"
-
-        return CommandResult(actions=[InputAction.run_agent(final_prompt)])
+            if user_input_text:
+                final_prompt += f"\n\nAdditional Instructions:\n{user_input_text}"
+
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    session_id=agent.session.id,
+                    input=model.UserInputPayload(text=final_prompt, images=user_input.images),
+                )
+            ]
+        )

klaude_code/command/refresh_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
-from klaude_code.protocol import commands, events
+from klaude_code.protocol import commands, events, model
 
 
 class RefreshTerminalCommand(CommandABC):
@@ -17,7 +17,8 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         import os
 
         os.system("cls" if os.name == "nt" else "clear")

klaude_code/command/registry.py

@@ -1,9 +1,9 @@
 from importlib.resources import files
 from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import Agent, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandResult
 from klaude_code.command.prompt_command import PromptCommand
-from klaude_code.protocol import commands, events, model
+from klaude_code.protocol import commands, events, model, op
 from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
@@ -12,6 +12,68 @@ if TYPE_CHECKING:
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
 
 
+def _command_key_to_str(key: commands.CommandName | str) -> str:
+    if isinstance(key, commands.CommandName):
+        return key.value
+    return key
+
+
+def _resolve_command_key(command_name_raw: str) -> commands.CommandName | str | None:
+    """Resolve raw command token to a registered command key.
+
+    Resolution order:
+    1) Exact match
+    2) Enum conversion (for standard commands)
+    3) Prefix match (supports abbreviations like `exp` -> `export`)
+
+    Prefix match rules:
+    - If there's exactly one prefix match, use it.
+    - If multiple matches exist and one command name is a prefix of all others,
+      treat it as the base command and use it (e.g. `export` over `export-online`).
+    - Otherwise, consider it ambiguous and return None.
+    """
+
+    if not command_name_raw:
+        return None
+
+    # Exact string match (works for both Enum and str keys because CommandName is a str Enum)
+    if command_name_raw in _COMMANDS:
+        return command_name_raw
+
+    # Enum conversion for standard commands
+    try:
+        enum_key = commands.CommandName(command_name_raw)
+    except ValueError:
+        enum_key = None
+    else:
+        if enum_key in _COMMANDS:
+            return enum_key
+
+    # Prefix match across all registered names
+    matching_keys: list[commands.CommandName | str] = []
+    matching_names: list[str] = []
+    for key in _COMMANDS:
+        key_str = _command_key_to_str(key)
+        if key_str.startswith(command_name_raw):
+            matching_keys.append(key)
+            matching_names.append(key_str)
+
+    if len(matching_keys) == 1:
+        return matching_keys[0]
+
+    if len(matching_keys) > 1:
+        # Prefer the base command when one is a prefix of all other matches.
+        base_matches = [
+            key
+            for key, key_name in zip(matching_keys, matching_names, strict=True)
+            if all(other.startswith(key_name) for other in matching_names if other != key_name)
+        ]
+        if len(base_matches) == 1:
+            return base_matches[0]
+
+    return None
+
+
 def register(cmd: "CommandABC") -> None:
     """Register a command instance. Order of registration determines display order."""
     _COMMANDS[cmd.name] = cmd
@@ -45,42 +107,53 @@ def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
 
 def is_slash_command_name(name: str) -> bool:
     _ensure_commands_loaded()
-    return name in _COMMANDS
+    return _resolve_command_key(name) is not None
 
 
-async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
+async def dispatch_command(user_input: model.UserInputPayload, agent: Agent, *, submission_id: str) -> CommandResult:
     _ensure_commands_loaded()
     # Detect command name
+    raw = user_input.text
     if not raw.startswith("/"):
-        return CommandResult(actions=[InputAction.run_agent(raw)])
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    id=submission_id,
+                    session_id=agent.session.id,
+                    input=user_input,
+                )
+            ]
+        )
 
     splits = raw.split(" ", maxsplit=1)
     command_name_raw = splits[0][1:]
     rest = " ".join(splits[1:]) if len(splits) > 1 else ""
 
-    # Try to match against registered commands (both Enum and string keys)
-    command_key = None
-
-    # First try exact string match
-    if command_name_raw in _COMMANDS:
-        command_key = command_name_raw
-    else:
-        # Then try Enum conversion for standard commands
-        try:
-            enum_key = commands.CommandName(command_name_raw)
-            if enum_key in _COMMANDS:
-                command_key = enum_key
-        except ValueError:
-            pass
-
+    command_key = _resolve_command_key(command_name_raw)
     if command_key is None:
-        return CommandResult(actions=[InputAction.run_agent(raw)])
+        return CommandResult(
+            operations=[
+                op.RunAgentOperation(
+                    id=submission_id,
+                    session_id=agent.session.id,
+                    input=user_input,
+                )
+            ]
+        )
 
     command = _COMMANDS[command_key]
     command_identifier: commands.CommandName | str = command.name
 
     try:
-        return await command.run(rest, agent)
+        user_input_for_command = model.UserInputPayload(text=rest, images=user_input.images)
+        result = await command.run(agent, user_input_for_command)
+        ops = list(result.operations or [])
+        for operation in ops:
+            if isinstance(operation, op.RunAgentOperation):
+                operation.id = submission_id
+        if ops:
+            result.operations = ops
+        return result
     except Exception as e:
         command_output = (
             model.CommandOutput(command_name=command_identifier, is_error=True)
@@ -106,11 +179,8 @@ def has_interactive_command(raw: str) -> bool:
         return False
     splits = raw.split(" ", maxsplit=1)
     command_name_raw = splits[0][1:]
-    try:
-        command_name = commands.CommandName(command_name_raw)
-    except ValueError:
-        return False
-    if command_name not in _COMMANDS:
+    command_key = _resolve_command_key(command_name_raw)
+    if command_key is None:
         return False
-    command = _COMMANDS[command_name]
+    command = _COMMANDS[command_key]
     return command.is_interactive

klaude_code/command/release_notes_cmd.py

@@ -68,7 +68,8 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 

klaude_code/command/status_cmd.py

@@ -132,7 +132,8 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         session = agent.session
         aggregated = accumulate_session_usage(session)
 

klaude_code/command/terminal_setup_cmd.py

@@ -21,7 +21,8 @@ class TerminalSetupCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
         try:

klaude_code/command/thinking_cmd.py

@@ -6,9 +6,9 @@ from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, llm_param, model
 
 # Thinking level options for different protocols
-RESPONSES_LEVELS = ["minimal", "low", "medium", "high"]
-RESPONSES_GPT51_LEVELS = ["none", "minimal", "low", "medium", "high"]
-RESPONSES_GPT52_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"]
+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"]
 
 ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
@@ -169,7 +169,8 @@ class ThinkingCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    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")
 
@@ -206,6 +207,7 @@ class ThinkingCommand(CommandABC):
 
         # Apply the new thinking configuration
         config.thinking = new_thinking
+        agent.session.model_thinking = new_thinking
         new_status = _format_current_thinking(config)
 
         return CommandResult(