klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/command/status_cmd.py

@@ -1,47 +1,70 @@
-from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
 
-def accumulate_session_usage(session: Session) -> tuple[model.Usage, int]:
-    """Accumulate usage statistics from all ResponseMetadataItems in session history.
+class AggregatedUsage(model.BaseModel):
+    """Aggregated usage statistics including per-model breakdown."""
 
-    Returns:
-        A tuple of (accumulated_usage, task_count)
+    total: model.Usage
+    by_model: list[model.TaskMetadata]
+    task_count: int
+
+
+def accumulate_session_usage(session: Session) -> AggregatedUsage:
+    """Accumulate usage statistics from all TaskMetadataItems in session history.
+
+    Includes both main agent and sub-agent task metadata, grouped by model+provider.
     """
-    total = model.Usage()
+    all_metadata: list[model.TaskMetadata] = []
     task_count = 0
 
     for item in session.conversation_history:
-        if isinstance(item, model.ResponseMetadataItem) and item.usage:
+        if isinstance(item, model.TaskMetadataItem):
             task_count += 1
-            usage = item.usage
-            total.input_tokens += usage.input_tokens
-            total.cached_tokens += usage.cached_tokens
-            total.reasoning_tokens += usage.reasoning_tokens
-            total.output_tokens += usage.output_tokens
-            total.total_tokens += usage.total_tokens
-
-            # Accumulate costs
-            if usage.input_cost is not None:
-                total.input_cost = (total.input_cost or 0.0) + usage.input_cost
-            if usage.output_cost is not None:
-                total.output_cost = (total.output_cost or 0.0) + usage.output_cost
-            if usage.cache_read_cost is not None:
-                total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
-            if usage.total_cost is not None:
-                total.total_cost = (total.total_cost or 0.0) + usage.total_cost
-
-            # Keep the latest context_usage_percent
-            if usage.context_usage_percent is not None:
-                total.context_usage_percent = usage.context_usage_percent
-
-    return total, task_count
-
-
-def _format_tokens(tokens: int) -> str:
+            all_metadata.append(item.main_agent)
+            all_metadata.extend(item.sub_agent_task_metadata)
+
+    # Aggregate by model+provider
+    by_model = model.TaskMetadata.aggregate_by_model(all_metadata)
+
+    # Calculate total from aggregated results
+    total = model.Usage()
+    for meta in by_model:
+        if not meta.usage:
+            continue
+        usage = meta.usage
+
+        # Set currency from first
+        if total.currency == "USD" and usage.currency:
+            total.currency = usage.currency
+
+        # Accumulate primary token fields (total_tokens is computed)
+        total.input_tokens += usage.input_tokens
+        total.cached_tokens += usage.cached_tokens
+        total.reasoning_tokens += usage.reasoning_tokens
+        total.output_tokens += usage.output_tokens
+
+        # Accumulate cost components (total_cost is computed)
+        if usage.input_cost is not None:
+            total.input_cost = (total.input_cost or 0.0) + usage.input_cost
+        if usage.output_cost is not None:
+            total.output_cost = (total.output_cost or 0.0) + usage.output_cost
+        if usage.cache_read_cost is not None:
+            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_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:
+            total.context_limit = usage.context_limit
+
+    return AggregatedUsage(total=total, by_model=by_model, task_count=task_count)
+
+
+def format_tokens(tokens: int) -> str:
     """Format token count with K/M suffix for readability."""
     if tokens >= 1_000_000:
         return f"{tokens / 1_000_000:.2f}M"
@@ -50,32 +73,54 @@ def _format_tokens(tokens: int) -> str:
     return str(tokens)
 
 
-def _format_cost(cost: float | None) -> str:
-    """Format cost in USD."""
+def format_cost(cost: float | None, currency: str = "USD") -> str:
+    """Format cost with currency symbol."""
     if cost is None:
         return "-"
+    symbol = "¥" if currency == "CNY" else "$"
     if cost < 0.01:
-        return f"${cost:.4f}"
-    return f"${cost:.2f}"
+        return f"{symbol}{cost:.4f}"
+    return f"{symbol}{cost:.2f}"
+
+
+def _format_model_usage_line(meta: model.TaskMetadata) -> str:
+    """Format a single model's usage as a line."""
+    model_label = meta.model_name
+    if meta.provider:
+        model_label = f"{meta.model_name} ({meta.provider})"
+
+    usage = meta.usage
+    if not usage:
+        return f"      {model_label}: no usage data"
+
+    cost_str = format_cost(usage.total_cost, usage.currency)
+    return (
+        f"      {model_label}: "
+        f"{format_tokens(usage.input_tokens)} input, "
+        f"{format_tokens(usage.output_tokens)} output, "
+        f"{format_tokens(usage.cached_tokens)} cache read, "
+        f"{format_tokens(usage.reasoning_tokens)} thinking, "
+        f"({cost_str})"
+    )
 
 
-def format_status_content(usage: model.Usage) -> str:
-    """Format session status as comma-separated text."""
-    parts: list[str] = []
+def format_status_content(aggregated: AggregatedUsage) -> str:
+    """Format session status with per-model breakdown."""
+    lines: list[str] = []
 
-    parts.append(f"Input: {_format_tokens(usage.input_tokens)}")
-    if usage.cached_tokens > 0:
-        parts.append(f"Cached: {_format_tokens(usage.cached_tokens)}")
-    parts.append(f"Output: {_format_tokens(usage.output_tokens)}")
-    parts.append(f"Total: {_format_tokens(usage.total_tokens)}")
+    # Total cost line
+    total_cost_str = format_cost(aggregated.total.total_cost, aggregated.total.currency)
+    lines.append(f"Total cost: {total_cost_str}")
 
-    if usage.total_cost is not None:
-        parts.append(f"Cost: {_format_cost(usage.total_cost)}")
+    # Per-model breakdown
+    if aggregated.by_model:
+        lines.append("Usage by model:")
+        for stats in aggregated.by_model:
+            lines.append(_format_model_usage_line(stats))
 
-    return ", ".join(parts)
+    return "\n".join(lines)
 
 
-@register_command
 class StatusCommand(CommandABC):
     """Display session usage statistics."""
 
@@ -87,25 +132,24 @@ 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
-        usage, task_count = accumulate_session_usage(session)
+        aggregated = accumulate_session_usage(session)
 
         event = events.DeveloperMessageEvent(
             session_id=session.id,
             item=model.DeveloperMessageItem(
-                content=format_status_content(usage),
+                content=format_status_content(aggregated),
                 command_output=model.CommandOutput(
                     command_name=self.name,
-                    ui_extra=model.ToolResultUIExtra(
-                        type=model.ToolResultUIExtraType.SESSION_STATUS,
-                        session_status=model.SessionStatusUIExtra(
-                            usage=usage,
-                            task_count=task_count,
-                        ),
+                    ui_extra=model.SessionStatusUIExtra(
+                        usage=aggregated.total,
+                        task_count=aggregated.task_count,
+                        by_model=aggregated.by_model,
                     ),
                 ),
             ),
         )
 
-        return CommandResult(events=[event])
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

klaude_code/command/terminal_setup_cmd.py

@@ -2,13 +2,10 @@ import os
 import subprocess
 from pathlib import Path
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
-from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
 
-@register_command
 class TerminalSetupCommand(CommandABC):
     """Setup shift+enter newline functionality in terminal"""
 
@@ -24,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:
@@ -42,7 +40,7 @@ class TerminalSetupCommand(CommandABC):
             return self._create_success_result(agent, message)
 
         except Exception as e:
-            return self._create_error_result(agent, f"Error configuring terminal: {str(e)}")
+            return self._create_error_result(agent, f"Error configuring terminal: {e!s}")
 
     def _setup_ghostty(self) -> str:
         """Configure shift+enter newline for Ghostty terminal"""
@@ -112,7 +110,7 @@ class TerminalSetupCommand(CommandABC):
                 )
 
         except Exception as e:
-            raise Exception(f"Error configuring iTerm: {str(e)}")
+            raise Exception(f"Error configuring iTerm: {e!s}") from e
 
     def _setup_vscode_family(self) -> str:
         """Configure shift+enter newline for VS Code family terminals (VS Code, Windsurf, Cursor).
@@ -223,7 +221,7 @@ class TerminalSetupCommand(CommandABC):
 
         return message
 
-    def _create_success_result(self, agent: Agent, message: str) -> CommandResult:
+    def _create_success_result(self, agent: "Agent", message: str) -> CommandResult:
         """Create success result"""
         return CommandResult(
             events=[
@@ -237,7 +235,7 @@ class TerminalSetupCommand(CommandABC):
             ]
         )
 
-    def _create_error_result(self, agent: Agent, message: str) -> CommandResult:
+    def _create_error_result(self, agent: "Agent", message: str) -> CommandResult:
         """Create error result"""
         return CommandResult(
             events=[

klaude_code/command/thinking_cmd.py

@@ -0,0 +1,98 @@
+import asyncio
+
+from prompt_toolkit.styles import Style
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+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
+
+SELECT_STYLE = Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
+        ("text", "ansibrightblack"),
+        ("question", "bold"),
+    ]
+)
+
+
+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
+
+    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=data.message,
+            items=items,
+            pointer="→",
+            style=SELECT_STYLE,
+            use_search_filter=False,
+        )
+        if result is None:
+            return None
+        return parse_thinking_value(result)
+    except KeyboardInterrupt:
+        return None
+
+
+async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking configuration based on the LLM protocol.
+
+    Returns the selected Thinking config, or None if user cancelled.
+    """
+    return await asyncio.to_thread(_select_thinking_sync, config)
+
+
+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, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+        if agent.profile is None:
+            return CommandResult(events=[])
+
+        config = agent.profile.llm_client.get_llm_config()
+        new_thinking = await select_thinking_for_protocol(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),
+                        ),
+                    )
+                ]
+            )
+
+        return CommandResult(
+            operations=[
+                op.ChangeThinkingOperation(
+                    session_id=agent.session.id,
+                    thinking=new_thinking,
+                )
+            ]
+        )

klaude_code/config/__init__.py

@@ -1,11 +1,19 @@
-from .config import Config, config_path, load_config
-from .list_model import display_models_and_providers
-from .select_model import select_model_from_config
+from .config import (
+    Config,
+    UserConfig,
+    config_path,
+    create_example_config,
+    example_config_path,
+    load_config,
+    print_no_available_models_hint,
+)
 
 __all__ = [
     "Config",
-    "load_config",
+    "UserConfig",
     "config_path",
-    "display_models_and_providers",
-    "select_model_from_config",
+    "create_example_config",
+    "example_config_path",
+    "load_config",
+    "print_no_available_models_hint",
 ]

klaude_code/config/assets/__init__.py

@@ -0,0 +1 @@
+# Asset files for config module