klaude-code 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

klaude_code/tui/command/copy_cmd.py

@@ -0,0 +1,52 @@
+from klaude_code.protocol import commands, events, message, model
+from klaude_code.tui.input.clipboard import copy_to_clipboard
+
+from .command_abc import Agent, CommandABC, CommandResult
+
+
+class CopyCommand(CommandABC):
+    """Copy the last assistant message to system clipboard."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.COPY
+
+    @property
+    def summary(self) -> str:
+        return "Copy last assistant message to clipboard"
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        last = _get_last_assistant_text(agent.session.conversation_history)
+        if not last:
+            return _developer_message(agent, "(no assistant message to copy)", self.name)
+
+        copy_to_clipboard(last)
+        return _developer_message(agent, "Copied last assistant message to clipboard.", self.name)
+
+
+def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
+    for item in reversed(history):
+        if not isinstance(item, message.AssistantMessage):
+            continue
+        content = message.join_text_parts(item.parts)
+        images = [part for part in item.parts if isinstance(part, message.ImageFilePart)]
+        formatted = message.format_saved_images(images, content)
+        return formatted.strip()
+    return ""
+
+
+def _developer_message(agent: Agent, content: str, command_name: commands.CommandName) -> CommandResult:
+    return CommandResult(
+        events=[
+            events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str(content),
+                    ui_extra=model.build_command_output_extra(command_name),
+                ),
+            )
+        ],
+        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/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)

klaude_code/tui/components/developer.py

@@ -143,7 +143,7 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
     content = message.join_text_parts(e.item.parts)
     match command_output.command_name:
         case commands.CommandName.HELP:
-            return Padding.indent(Text.from_markup(content or ""), level=2)
+            return Padding.indent(Text.from_markup(content or "", style=ThemeKey.TOOL_RESULT), level=2)
         case commands.CommandName.STATUS:
             return _render_status_output(command_output)
         case commands.CommandName.RELEASE_NOTES:
@@ -178,14 +178,14 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
     """Render fork session output with usage instructions."""
     if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
-        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
+        return Padding.indent(Text("(no session id)", style=ThemeKey.TOOL_RESULT), level=2)
 
     grid = Table.grid(padding=(0, 1))
     session_id = command_output.ui_extra.session_id
-    grid.add_column(style=ThemeKey.METADATA, overflow="fold")
+    grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
-    grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.METADATA))
-    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.METADATA_BOLD))
+    grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
+    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 
@@ -193,24 +193,24 @@ def _render_fork_session_output(command_output: model.CommandOutput) -> Renderab
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
     """Render session status with total cost and per-model breakdown."""
     if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):
-        return Text("(no status data)", style=ThemeKey.METADATA)
+        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
 
     status = command_output.ui_extra
     usage = status.usage
 
     table = Table.grid(padding=(0, 2))
-    table.add_column(style=ThemeKey.METADATA, overflow="fold")
-    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
+    table.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     # Total cost line
     table.add_row(
-        Text("Total cost:", style=ThemeKey.METADATA_BOLD),
-        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.METADATA_BOLD),
+        Text("Total cost:", style=ThemeKey.TOOL_RESULT_BOLD),
+        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.TOOL_RESULT_BOLD),
     )
 
     # Per-model breakdown
     if status.by_model:
-        table.add_row(Text("Usage by model:", style=ThemeKey.METADATA_BOLD), "")
+        table.add_row(Text("Usage by model:", style=ThemeKey.TOOL_RESULT_BOLD), "")
         for meta in status.by_model:
             model_label = meta.model_name
             if meta.provider:

klaude_code/tui/components/metadata.py

@@ -188,7 +188,7 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
             ("Σ ", ThemeKey.METADATA_DIM),
             ("total ", ThemeKey.METADATA_DIM),
             (currency_symbol, ThemeKey.METADATA_DIM),
-            (f"{total_cost:.4f}", ThemeKey.METADATA_BOLD),
+            (f"{total_cost:.4f}", ThemeKey.METADATA),
         )
         grid = create_grid()
         grid.add_row(Text(" ", style=ThemeKey.METADATA_DIM), total_line)

klaude_code/tui/components/rich/theme.py

@@ -250,8 +250,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.USER_INPUT.value: palette.magenta,
                 ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
                 ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
-                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold reverse " + palette.blue,
-                ThemeKey.USER_INPUT_SKILL.value: "bold reverse " + palette.green,
+                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold " + palette.blue,
+                ThemeKey.USER_INPUT_SKILL.value: "bold " + palette.green,
                 # ASSISTANT
                 ThemeKey.ASSISTANT_MESSAGE_MARK.value: "bold",
                 # METADATA

klaude_code/tui/components/tools.py

@@ -37,7 +37,6 @@ MARK_MERMAID = "⧉"
 MARK_WEB_FETCH = "→"
 MARK_WEB_SEARCH = "✱"
 MARK_DONE = "✔"
-MARK_SKILL = "✪"
 
 # Todo status markers
 MARK_TODO_PENDING = "▢"
@@ -491,7 +490,7 @@ def render_mermaid_tool_result(
 
     link_info = _extract_mermaid_link(tr.ui_extra)
     if link_info is None:
-        return render_generic_tool_result(tr.result, is_error=tr.status == "error")
+        return render_generic_tool_result(tr.result, is_error=tr.is_error)
 
     use_osc8 = supports_osc8_hyperlinks()
     viewer = _render_mermaid_viewer_link(tr, link_info, use_osc8=use_osc8)
@@ -537,7 +536,6 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.WRITE: "Writing",
     tools.TODO_WRITE: "Planning",
     tools.UPDATE_PLAN: "Planning",
-    tools.SKILL: "Skilling",
     tools.MERMAID: "Diagramming",
     tools.WEB_FETCH: "Fetching Web",
     tools.WEB_SEARCH: "Searching Web",
@@ -589,8 +587,6 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_update_plan_tool_call(e.arguments)
         case tools.MERMAID:
             return render_mermaid_tool_call(e.arguments)
-        case tools.SKILL:
-            return render_generic_tool_call(e.tool_name, e.arguments, MARK_SKILL)
         case tools.REPORT_BACK:
             return render_report_back_tool_call()
         case tools.WEB_FETCH:
@@ -649,7 +645,7 @@ def render_tool_result(
         return TreeQuote.for_tool_result(content, is_last=e.is_last_in_turn)
 
     # Handle error case
-    if e.status == "error" and e.ui_extra is None:
+    if e.is_error and e.ui_extra is None:
         return wrap(render_generic_tool_result(e.result, is_error=True))
 
     # Render multiple ui blocks if present
@@ -666,7 +662,7 @@ def render_tool_result(
     # Show truncation info if output was truncated and saved to file
     truncation_info = get_truncation_info(e)
     if truncation_info:
-        result = render_generic_tool_result(e.result, is_error=e.status == "error")
+        result = render_generic_tool_result(e.result, is_error=e.is_error)
         return wrap(Group(render_truncation_info(truncation_info), result))
 
     diff_ui = _extract_diff(e.ui_extra)
@@ -675,7 +671,7 @@ def render_tool_result(
     def _render_fallback() -> TreeQuote:
         if len(e.result.strip()) == 0:
             return wrap(render_generic_tool_result("(no content)"))
-        return wrap(render_generic_tool_result(e.result, is_error=e.status == "error"))
+        return wrap(render_generic_tool_result(e.result, is_error=e.is_error))
 
     match e.tool_name:
         case tools.READ:

klaude_code/tui/components/user_input.py

@@ -4,7 +4,6 @@ from rich.console import Group, RenderableType
 from rich.text import Text
 
 from klaude_code.skill import get_available_skills
-from klaude_code.tui.command import is_slash_command_name
 from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
 
@@ -54,35 +53,28 @@ def _is_valid_skill_name(name: str) -> bool:
 def render_user_input(content: str) -> RenderableType:
     """Render a user message as a group of quoted lines with styles.
 
-    - Highlights slash command on the first line if recognized
+    - Highlights slash command token on the first line
     - Highlights $skill pattern on the first line if recognized
     - Highlights @file patterns in all lines
     """
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
-    has_command = False
-    command_style: str | None = None
     for i, line in enumerate(lines):
         line_text = render_at_pattern(line)
 
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)
-            if is_slash_command_name(splits[0][1:]):
-                has_command = True
-                command_style = ThemeKey.USER_INPUT_SLASH_COMMAND
-                line_text = Text.assemble(
-                    (f"{splits[0]}", ThemeKey.USER_INPUT_SLASH_COMMAND),
-                    " ",
-                    render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
-                )
-                renderables.append(line_text)
-                continue
+            line_text = Text.assemble(
+                (splits[0], ThemeKey.USER_INPUT_SLASH_COMMAND),
+                " ",
+                render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
+            )
+            renderables.append(line_text)
+            continue
 
         if i == 0 and (line.startswith("$") or line.startswith("¥")):
             m = SKILL_RENDER_PATTERN.match(line)
             if m and _is_valid_skill_name(m.group(1)):
-                has_command = True
-                command_style = ThemeKey.USER_INPUT_SKILL
                 skill_token = m.group(0)  # e.g. "$skill-name"
                 rest = line[len(skill_token) :]
                 line_text = Text.assemble(
@@ -95,11 +87,7 @@ def render_user_input(content: str) -> RenderableType:
         renderables.append(line_text)
     grid = create_grid()
     grid.padding = (0, 0)
-    mark = (
-        Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
-        if not has_command
-        else Text("  ", style=command_style or ThemeKey.USER_INPUT_SLASH_COMMAND)
-    )
+    mark = Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
     grid.add_row(mark, Group(*renderables))
     return grid
 

klaude_code/tui/machine.py

@@ -521,13 +521,15 @@ class DisplayStateMachine:
                     self._spinner.finish_sub_agent_tool_call(e.tool_call_id, get_tool_active_form(e.tool_name))
                     cmds.extend(self._spinner_update_commands())
 
-                if s.is_sub_agent and e.status == "success":
+                if s.is_sub_agent and not e.is_error:
                     return cmds
 
                 cmds.append(RenderToolResult(event=e, is_sub_agent_session=s.is_sub_agent))
                 return cmds
 
             case events.TaskMetadataEvent() as e:
+                cmds.append(EndThinkingStream(e.session_id))
+                cmds.append(EndAssistantStream(e.session_id))
                 cmds.append(RenderTaskMetadata(e))
                 return cmds
 

klaude_code/tui/renderer.py

@@ -396,7 +396,7 @@ class TUICommandRenderer:
         if c_tools.is_sub_agent_tool(e.tool_name):
             return
 
-        if is_sub_agent and e.status == "error":
+        if is_sub_agent and e.is_error:
             error_msg = truncate_head(e.result)
             self.print(c_errors.render_tool_error(error_msg))
             return

klaude_code/tui/runner.py

@@ -77,12 +77,12 @@ async def submit_user_input_payload(
         raise ValueError("Multiple RunAgentOperation results are not supported")
 
     for run_op in run_ops:
-        run_op.persist_user_input = cmd_result.persist_user_input
+        run_op.persist_user_input = cmd_result.persist
         run_op.emit_user_message_event = False
 
     if cmd_result.events:
         for evt in cmd_result.events:
-            if cmd_result.persist_events and isinstance(evt, events.DeveloperMessageEvent):
+            if cmd_result.persist and isinstance(evt, events.DeveloperMessageEvent):
                 agent.session.append_history([evt.item])
             await executor.context.emit_event(evt)
 

klaude_code/tui/terminal/selector.py

@@ -19,6 +19,8 @@ from prompt_toolkit.layout.containers import Container, ScrollOffsets
 from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
 from prompt_toolkit.styles import Style, merge_styles
 
+from klaude_code.ui.common import format_model_params
+
 
 @dataclass(frozen=True, slots=True)
 class SelectItem[T]:
@@ -49,26 +51,12 @@ def build_model_select_items(models: list[Any]) -> list[SelectItem[str]]:
     max_model_name_length = max(len(m.model_name) for m in models)
     num_width = len(str(len(models)))
 
-    def _thinking_info(m: Any) -> 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 idx, m in enumerate(models, 1):
         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_parts.extend(format_model_params(m.model_params))
         meta_str = " · ".join(meta_parts)
         title = [
             ("class:meta", f"{idx:>{num_width}}. "),

klaude_code/ui/__init__.py

@@ -10,33 +10,9 @@ Terminal (Rich/prompt-toolkit) UI lives in `klaude_code.tui`.
 from .core.display import DisplayABC
 from .core.input import InputProviderABC
 from .debug_mode import DebugEventDisplay
-from .exec_mode import ExecDisplay, StreamJsonDisplay
-
-
-def create_exec_display(debug: bool = False, stream_json: bool = False) -> DisplayABC:
-    """
-    Create a display for exec (non-interactive) mode.
-
-    Args:
-        debug: If True, wrap the display with DebugEventDisplay to log all events.
-        stream_json: If True, stream all events as JSON lines instead of normal output.
-
-    Returns:
-        A DisplayABC implementation that only outputs task results.
-    """
-    if stream_json:
-        return StreamJsonDisplay()
-    exec_display = ExecDisplay()
-    if debug:
-        return DebugEventDisplay(exec_display)
-    return exec_display
-
 
 __all__ = [
     "DebugEventDisplay",
     "DisplayABC",
-    "ExecDisplay",
     "InputProviderABC",
-    "StreamJsonDisplay",
-    "create_exec_display",
 ]

klaude_code/ui/common.py

@@ -101,6 +101,7 @@ def format_model_params(model_params: "LLMConfigModelParameter") -> list[str]:
     - "reasoning medium"
     - "thinking budget 10000"
     - "verbosity 2"
+    - "image generation"
     - "provider-routing: {…}"
     """
     parts: list[str] = []
@@ -119,8 +120,8 @@ def format_model_params(model_params: "LLMConfigModelParameter") -> list[str]:
     if model_params.provider_routing:
         parts.append(f"provider routing {_format_provider_routing(model_params.provider_routing)}")
 
-    if model_params.modalities:
-        parts.append(f"modalities {','.join(model_params.modalities)}")
+    if model_params.modalities and any(m.casefold() == "image" for m in model_params.modalities):
+        parts.append("image generation")
 
     if model_params.image_config:
         if model_params.image_config.aspect_ratio:

klaude_code/ui/core/display.py

@@ -10,8 +10,8 @@ class DisplayABC(ABC):
     Abstract base class for UI display implementations.
 
     A Display is responsible for rendering events from the executor to the user.
-    Implementations can range from simple text output (ExecDisplay) to rich
-    interactive terminals (TUIDisplay) or debugging wrappers (DebugEventDisplay).
+    Implementations can range from minimal text output to rich interactive
+    terminals (TUIDisplay) or debugging wrappers (DebugEventDisplay).
 
     Lifecycle:
         1. start() is called once before any events are consumed.

{klaude_code-2.1.0.dist-info → klaude_code-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.1.0
+Version: 2.2.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -25,21 +25,19 @@ Description-Content-Type: text/markdown
 Minimal code agent CLI.
 
 ## Features
-- **Multi-provider**: Anthropic, OpenAI Responses API, OpenRouter
+- **Multi-provider**: Anthropic Message API, OpenAI Responses API, OpenRouter, Claude Max OAuth and ChatGPT Codex OAuth etc.
 - **Keep reasoning item in context**: Interleaved thinking support
-- **Model-aware tools**: Claude Code tools for Sonnet, `apply_patch` for GPT-5/Codex
-- **Structured sub-agent output**: Define JSON schema, get schema-compliant responses via constrained decoding
+- **Model-aware tools**: Claude Code tool set for Opus, `apply_patch` for GPT-5/Codex
+- **Reminders**: Cooldown-based todo tracking, instruction reinforcement and external file change reminder
+- **Sub-agents**: Task, Explore, Web, ImageGen
+- **Structured sub-agent output**: Main agent defines JSON schema and get schema-compliant responses via constrained decoding
 - **Recursive `@file` mentions**: Circular dependency protection, relative path resolution
-- **Reminders**: Cooldown-based todo tracking and instruction reinforcement
 - **External file sync**: Monitoring for external edits (linter, manual)
 - **Interrupt handling**: Ctrl+C preserves partial responses and synthesizes tool cancellation results
 - **Output truncation**: Large outputs saved to file system with snapshot links
-- **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
+- **Agent Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
 - **Sessions**: Resumable with `--continue`
-- **Cost tracking**: Automatic API cost calculation and display (USD/CNY)
-- **Version update check**: Background PyPI version check with upgrade prompts
-- **Terminal title**: Shows current directory and model name
-- **Mermaid diagrams**: Interactive local HTML viewer with zoom, pan, and SVG export
+- **Mermaid diagrams**: Terminal image preview and Interactive local HTML viewer with zoom, pan, and SVG export
 - **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
@@ -59,32 +57,23 @@ Or use the built-in alias command:
 ```bash
 klaude update
 klaude upgrade
-```
-
-To show version:
-
-```bash
 klaude --version
-klaude -v
-klaude version
+
 ```
 
 ## Usage
 
-### Interactive Mode
-
 ```bash
 klaude [--model <name>] [--select-model]
 ```
 
 **Options:**
-- `--version`/`-V`/`-v`: Show version and exit.
 - `--model`/`-m`: Preferred model name (exact match picks immediately; otherwise opens the interactive selector filtered by this value).
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.
 - `--resume`/`-r`: Select a session to resume for this project.
 - `--resume-by-id <id>`: Resume a session by its ID directly.
-- `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit) and no system prompts.
+- `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit, Write) and no system prompts.
 
 **Model selection behavior:**
 - Default: uses `main_model` from config.
@@ -255,48 +244,16 @@ provider_list:
           context_limit: 128000
 ```
 
-##### Full Example
-
-```yaml
-# User configuration - merged with built-in config
-main_model: opus
-
-sub_agent_models:
-  explore: sonnet
-  task: opus
-  webagent: sonnet
-
-provider_list:
-  # Add models to built-in openrouter
-  - provider_name: openrouter
-    model_list:
-      - model_name: qwen-coder
-        model_params:
-          model: qwen/qwen-2.5-coder-32b-instruct
-          context_limit: 131072
-
-  # Add a completely new provider
-  - provider_name: local-ollama
-    protocol: openai
-    base_url: http://localhost:11434/v1
-    api_key: ollama
-    model_list:
-      - model_name: local-llama
-        model_params:
-          model: llama3.2
-          context_limit: 8192
-```
-
 ##### Supported Protocols
 
-- `anthropic` - Anthropic Claude API
+- `anthropic` - Anthropic Messages API
 - `claude_oauth` - Claude OAuth (for Claude Pro/Max subscribers)
-- `openai` - OpenAI-compatible API
+- `openai` - OpenAI Chat Completion API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
-- `openrouter` - OpenRouter API
-- `google` - Google Gemini API
-- `bedrock` - AWS Bedrock (uses AWS credentials instead of api_key)
 - `codex_oauth` - OpenAI Codex CLI (OAuth-based, for ChatGPT Pro subscribers)
+- `openrouter` - OpenRouter API (handling `reasoning_details` for interleaved thinking)
+- `google` - Google Gemini API
+- `bedrock` - AWS Bedrock for Claude(uses AWS credentials instead of api_key)
 
 List configured providers and models:
 
@@ -338,6 +295,7 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 - `/model` - Switch the active LLM during the session.
 - `/thinking` - Configure model thinking/reasoning level.
 - `/clear` - Clear the current conversation context.
+- `/copy` - Copy last assistant message.
 - `/status` - Show session usage statistics (cost, tokens, model breakdown).
 - `/resume` - Select and resume a previous session.
 - `/fork-session` - Fork current session to a new session ID (supports interactive fork point selection).
@@ -364,29 +322,6 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Backspace`          | Delete character or selected text           |
 | `c` (with selection) | Copy selected text to clipboard             |
 
-### Non-Interactive Headless Mode (exec)
-
-Execute a single command without starting the interactive REPL:
-
-```bash
-# Direct input
-klaude exec "what is 2+2?"
-
-# Pipe input
-echo "hello world" | klaude exec
-
-# With model selection
-
-# Exact model name (non-interactive)
-echo "generate quicksort in python" | klaude exec --model gpt-5.1
-
-# Partial/ambiguous name opens the interactive selector (filtered)
-echo "generate quicksort in python" | klaude exec --model gpt
-
-# Stream all events as JSON lines (for programmatic processing)
-klaude exec "what is 2+2?" --stream-json
-```
-
 ### Sub-Agents
 
 The main agent can spawn specialized sub-agents for specific tasks: